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

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

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

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

以下代码是StringRequest的get请求：

[java] view plain copy

1. //get请求

[java] view plain copy

1. privatevoidloadGetStr(Stringurl){
3. StringRequestsrReq=newStringRequest(Request.Method.GET,url,
4. newStrListener(),newStrErrListener()){
6. protectedfinalStringTYPE_UTF8_CHARSET="charset=UTF-8";
8. //重写parseNetworkResponse方法改变返回头参数解决乱码问题
9. //主要是看服务器编码，如果服务器编码不是UTF-8的话那么就需要自己转换，反之则不需要
10. @Override
11. protectedResponse<String>parseNetworkResponse(
12. NetworkResponseresponse){
13. try{
14. Stringtype=response.headers.get(HTTP.CONTENT_TYPE);
15. if(type==null){
16. type=TYPE_UTF8_CHARSET;
17. response.headers.put(HTTP.CONTENT_TYPE,type);
18. }elseif(!type.contains("UTF-8")){
19. type+=";"+TYPE_UTF8_CHARSET;
20. response.headers.put(HTTP.CONTENT_TYPE,type);
21. }
22. }catch(Exceptione){
23. }
24. returnsuper.parseNetworkResponse(response);
25. }
26. };
27. srReq.setShouldCache(true);//控制是否缓存
28. startVolley(srReq);
29. }

以下代码是 JsonObjectRequest的post 请求： [java] view plain copy

1. //post请求
2. privatevoidloadPostJson(Stringurl){
3. //第二个参数说明:
4. //ConstructorwhichdefaultstoGETifjsonRequestisnull,POST
5. //otherwise.
6. //默认情况下设成null为get方法,否则为post方法。
7. JsonObjectRequestsrReq=newJsonObjectRequest(url,null,
8. newJsonListener(),newStrErrListener()){
10. @Override
11. protectedMap<String,String>getParams()throwsAuthFailureError{
12. Map<String,String>map=newHashMap<String,String>();
13. map.put("w","2459115");
14. map.put("u","f");
15. returnmap;
16. }
17. };
18. srReq.setShouldCache(false);//控制是否缓存
19. startVolley(srReq);
20. }

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

[java] view plain copy

1. //Str请求成功回调
2. privateclassStrListenerimplementsListener<String>{
4. @Override
5. publicvoidonResponse(Stringarg0){
6. Log.e(Tag,arg0);
8. }
10. }
12. //Gson请求成功回调
13. privateclassGsonListenerimplementsListener<ErrorRsp>{
15. @Override
16. publicvoidonResponse(ErrorRsparg0){
17. Toast.makeText(mContext,arg0.toString(),Toast.LENGTH_LONG).show();
18. }
20. }
21. //共用失败回调
22. privateclassStrErrListenerimplementsErrorListener{
24. @Override
25. publicvoidonErrorResponse(VolleyErrorarg0){
26. Toast.makeText(mContext,
27. VolleyErrorHelper.getMessage(arg0,mContext),
28. Toast.LENGTH_LONG).show();
29. }
31. }

接下来是 ImageRequest [java] view plain copy

1. /**
2. *第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，
3. *指定成0的话就表示不管图片有多大，都不会进行压缩。
4. *
5. *@paramurl
6. *图片地址
7. *@paramlistener
8. *@parammaxWidth
9. *指定允许图片最大的宽度
10. *@parammaxHeight
11. *指定允许图片最大的高度
12. *@paramdecodeConfig
13. *指定图片的颜色属性，Bitmap.Config下的几个常量.
14. *@paramerrorListener
15. */
16. privatevoidgetImageRequest(finalImageViewiv,Stringurl){
17. ImageRequestimReq=newImageRequest(url,newListener<Bitmap>(){
19. @Override
20. publicvoidonResponse(Bitmaparg0){
21. iv.setImageBitmap(arg0);
22. }
23. },60,60,Bitmap.Config.ARGB_8888,newStrErrListener());
24. startVolley(imReq);
25. }

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

[java] view plain copy

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

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

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

[java] view plain copy

1. publicclassImageAdapterextendsArrayAdapter<String>{
3. privateRequestQueuemQueue;
4. privateImageLoadermImageLoader;
6. publicImageAdapter(Contextcontext,List<String>objects){
7. super(context,0,objects);
8. mQueue=Volley.newRequestQueue(getContext());
9. mImageLoader=newImageLoader(mQueue,newBitmapCache());
10. }
12. @Override
13. publicViewgetView(intposition,ViewconvertView,ViewGroupparent){
14. Stringurl=getItem(position);
15. ImageViewimageView;
16. if(convertView==null){
17. imageView=newImageView(getContext());
18. }else{
19. imageView=(ImageView)convertView;
20. }
21. //getImageListener（imageView控件对象，默认图片地址，失败图片地址）;
22. ImageListenerlistener=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. returnimageView;
26. }
28. }

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

[java] view plain copy

1. publicclass<spanstyle="font-family:Arial;">BitmapCache</span><spanstyle="font-family:Arial;">extendsLruCache<String,Bitmap>implementsImageCache{</span>
2. //LruCache原理：Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。当cache已满的时候加入新的item时，在队列尾部的item会被回收。
3. //解释：当超出指定内存值则移除最近最少用的图片内存
4. publicstaticintgetDefaultLruCacheSize(){
5. //拿到最大内存
6. finalintmaxMemory=(int)(Runtime.getRuntime().maxMemory()/1024);
7. //拿到内存的八分之一来做图片内存缓存
8. finalintcacheSize=maxMemory/8;
10. returncacheSize;
11. }
13. publicBitmapLruCache(){
14. this(getDefaultLruCacheSize());
15. }
17. publicBitmapLruCache(intsizeInKiloBytes){
18. super(sizeInKiloBytes);
19. }
21. @Override
22. protectedintsizeOf(Stringkey,Bitmapvalue){
23. returnvalue.getRowBytes()*value.getHeight()/1024;
24. }
26. @Override
27. publicBitmapgetBitmap(Stringurl){
28. returnget(url);
29. }
31. @Override
32. publicvoidputBitmap(Stringurl,Bitmapbitmap){
33. put(url,bitmap);
34. }
35. }

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

[html] view plain copy

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

1. privatevoidnetworkImageViewUse(NetworkImageViewiv,Stringurl){
2. ImageLoaderimLoader=newImageLoader(mQueue,newBitmapLruCache());
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

1. request.setTag("MyTag");

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

[java] view plain copy

1. request.cancelAll("MyTag");

Volley的架构设计：

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

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

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

[java] view plain copy

1. packagecom.chronocloud.lib.base;
3. importandroid.app.Application;
4. importandroid.text.TextUtils;
6. importcom.android.volley.Request;
7. importcom.android.volley.RequestQueue;
8. importcom.android.volley.VolleyLog;
9. importcom.android.volley.toolbox.Volley;
11. publicclassApplicationControllerextendsApplication{
13. /**
14. *LogorrequestTAG
15. */
16. publicstaticfinalStringTAG="VolleyPatterns";
18. /**
19. *GlobalrequestqueueforVolley
20. */
21. privateRequestQueuemRequestQueue;
23. /**
24. *Asingletoninstanceoftheapplicationclassforeasyaccessinother
25. *places
26. */
27. privatestaticApplicationControllersInstance;
29. @Override
30. publicvoidonCreate(){
31. super.onCreate();
33. //initializethesingleton
34. sInstance=this;
35. }
37. /**
38. *@returnApplicationControllersingletoninstance
39. */
40. publicstaticsynchronizedApplicationControllergetInstance(){
41. returnsInstance;
42. }
44. /**
45. *@returnTheVolleyRequestqueue,thequeuewillbecreatedifitisnull
46. */
47. publicRequestQueuegetRequestQueue(){
48. //lazyinitializetherequestqueue,thequeueinstancewillbe
49. //createdwhenitisaccessedforthefirsttime
50. if(mRequestQueue==null){
51. //1
52. //2
53. synchronized(ApplicationController.class){
54. if(mRequestQueue==null){
55. mRequestQueue=Volley
56. .newRequestQueue(getApplicationContext());
57. }
58. }
59. }
60. returnmRequestQueue;
61. }
63. /**
64. *Addsthespecifiedrequesttotheglobalqueue,iftagisspecifiedthen
65. *itisusedelseDefaultTAGisused.
66. *
67. *@paramreq
68. *@paramtag
69. */
70. public<T>voidaddToRequestQueue(Request<T>req,Stringtag){
71. //setthedefaulttagiftagisempty
72. req.setTag(TextUtils.isEmpty(tag)?TAG:tag);
74. VolleyLog.d("Addingrequesttoqueue:%s",req.getUrl());
76. getRequestQueue().add(req);
77. }
79. /**
80. *AddsthespecifiedrequesttotheglobalqueueusingtheDefaultTAG.
81. *
82. *@paramreq
83. *@paramtag
84. */
85. public<T>voidaddToRequestQueue(Request<T>req){
86. //setthedefaulttagiftagisempty
87. req.setTag(TAG);
89. getRequestQueue().add(req);
90. }
92. /**
93. *CancelsallpendingrequestsbythespecifiedTAG,itisimportantto
94. *specifyaTAGsothatthepending/ongoingrequestscanbecancelled.
95. *
96. *@paramtag
97. */
98. publicvoidcancelPendingRequests(Objecttag){
99. if(mRequestQueue!=null){
100. mRequestQueue.cancelAll(tag);
101. }
102. }
103. }

接下来 就是Volley虽然给我们提供了很多不同的Request（JsonObjectRequest,JsonArrayRequest,StringRequest,ImageRequest），但是还是满足不了我们实战中的需求，我们实战开发中经常用到的是xml格式，Gson解析。

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

XmlRequest：

[java] view plain copy

1. publicclassXMLRequestextendsRequest<XmlPullParser>{
3. privatefinalListener<XmlPullParser>mListener;
5. publicXMLRequest(intmethod,Stringurl,Listener<XmlPullParser>listener,
6. ErrorListenererrorListener){
7. super(method,url,errorListener);
8. mListener=listener;
9. }
11. publicXMLRequest(Stringurl,Listener<XmlPullParser>listener,ErrorListenererrorListener){
12. this(Method.GET,url,listener,errorListener);
13. }
15. @Override
16. protectedResponse<XmlPullParser>parseNetworkResponse(NetworkResponseresponse){
17. try{
18. StringxmlString=newString(response.data,
19. HttpHeaderParser.parseCharset(response.headers));
20. XmlPullParserFactoryfactory=XmlPullParserFactory.newInstance();
21. XmlPullParserxmlPullParser=factory.newPullParser();
22. xmlPullParser.setInput(newStringReader(xmlString));
23. returnResponse.success(xmlPullParser,HttpHeaderParser.parseCacheHeaders(response));
24. }catch(UnsupportedEncodingExceptione){
25. returnResponse.error(newParseError(e));
26. }catch(XmlPullParserExceptione){
27. returnResponse.error(newParseError(e));
28. }
29. }
31. @Override
32. protectedvoiddeliverResponse(XmlPullParserresponse){
33. mListener.onResponse(response);
34. }
36. }

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

[java] view plain copy

1. publicclassGsonRequest<T>extendsRequest<T>{
3. privatefinalListener<T>mListener;
5. privateGsonmGson;
7. privateClass<T>mClass;
9. publicGsonRequest(intmethod,Stringurl,Class<T>clazz,Listener<T>listener,
10. ErrorListenererrorListener){
11. super(method,url,errorListener);
12. mGson=newGson();
13. mClass=clazz;
14. mListener=listener;
15. }
17. publicGsonRequest(Stringurl,Class<T>clazz,Listener<T>listener,
18. ErrorListenererrorListener){
19. this(Method.GET,url,clazz,listener,errorListener);
20. }
22. @Override
23. protectedResponse<T>parseNetworkResponse(NetworkResponseresponse){
24. try{
25. StringjsonString=newString(response.data,
26. HttpHeaderParser.parseCharset(response.headers));
27. returnResponse.success(mGson.fromJson(jsonString,mClass),
28. HttpHeaderParser.parseCacheHeaders(response));
29. }catch(UnsupportedEncodingExceptione){
30. returnResponse.error(newParseError(e));
31. }
32. }
34. @Override
35. protectedvoiddeliverResponse(Tresponse){
36. mListener.onResponse(response);
37. }
39. }

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

[java] view plain copy

1. //共用失败回调
2. privateclassStrErrListenerimplementsErrorListener{
4. @Override
5. publicvoidonErrorResponse(VolleyErrorarg0){
6. Toast.makeText(mContext,
7. VolleyErrorHelper.getMessage(arg0,mContext),
8. Toast.LENGTH_LONG).show();
9. }
11. }

以上代码有个VolleyError对象，我们可以从这个对象上下手：

[java] view plain copy

1. packagecom.example.volley;
3. importjava.util.HashMap;
4. importjava.util.Map;
6. importandroid.content.Context;
8. importcom.android.volley.AuthFailureError;
9. importcom.android.volley.NetworkError;
10. importcom.android.volley.NetworkResponse;
11. importcom.android.volley.NoConnectionError;
12. importcom.android.volley.ServerError;
13. importcom.android.volley.TimeoutError;
14. importcom.android.volley.VolleyError;
15. importcom.google.gson.Gson;
16. importcom.google.gson.reflect.TypeToken;
17. //正如前面代码看到的，在创建一个请求时，需要添加一个错误监听onErrorResponse。如果请求发生异常，会返回一个VolleyError实例。
18. //以下是Volley的异常列表：
19. //AuthFailureError：如果在做一个HTTP的身份验证，可能会发生这个错误。
20. //NetworkError：Socket关闭，服务器宕机，DNS错误都会产生这个错误。
21. //NoConnectionError：和NetworkError类似，这个是客户端没有网络连接。
22. //ParseError：在使用JsonObjectRequest或JsonArrayRequest时，如果接收到的JSON是畸形，会产生异常。
23. //SERVERERROR：服务器的响应的一个错误，最有可能的4xx或5xxHTTP状态代码。
24. //TimeoutError：Socket超时，服务器太忙或网络延迟会产生这个异常。默认情况下，Volley的超时时间为2.5秒。如果得到这个错误可以使用RetryPolicy。
26. publicclassVolleyErrorHelper{
28. /**
29. *Returnsappropriatemessagewhichistobedisplayedtotheuseragainst
30. *thespecifiederrorobject.
31. *
32. *@paramerror
33. *@paramcontext
34. *@return
35. */
36. publicstaticStringgetMessage(Objecterror,Contextcontext){
37. if(errorinstanceofTimeoutError){
38. returncontext.getResources().getString(
39. R.string.generic_server_down);
40. }elseif(isServerProblem(error)){
41. returnhandleServerError(error,context);
42. }elseif(isNetworkProblem(error)){
43. returncontext.getResources().getString(R.string.no_internet);
44. }
45. returncontext.getResources().getString(R.string.generic_error);
46. }
48. /**
49. *Determineswhethertheerrorisrelatedtonetwork
50. *
51. *@paramerror
52. *@return
53. */
54. privatestaticbooleanisNetworkProblem(Objecterror){
55. return(errorinstanceofNetworkError)
56. ||(errorinstanceofNoConnectionError);
57. }
59. /**
60. *Determineswhethertheerrorisrelatedtoserver
61. *
62. *@paramerror
63. *@return
64. */
65. privatestaticbooleanisServerProblem(Objecterror){
66. return(errorinstanceofServerError)
67. ||(errorinstanceofAuthFailureError);
68. }
70. /**
71. *Handlestheservererror,triestodeterminewhethertoshowastock
72. *messageortoshowamessageretrievedfromtheserver.
73. *
74. *@paramerr
75. *@paramcontext
76. *@return
77. */
78. privatestaticStringhandleServerError(Objecterr,Contextcontext){
79. VolleyErrorerror=(VolleyError)err;
81. NetworkResponseresponse=error.networkResponse;
83. if(response!=null){
84. switch(response.statusCode){
85. case404:
86. case422:
87. case401:
88. try{
89. //servermightreturnerrorlikethis{"error":
90. //"Someerroroccured"}
91. //Use"Gson"toparsetheresult
92. HashMap<String,String>result=newGson().fromJson(
93. newString(response.data),
94. newTypeToken<Map<String,String>>(){
95. }.getType());
97. if(result!=null&&result.containsKey("error")){
98. returnresult.get("error");
99. }
101. }catch(Exceptione){
102. e.printStackTrace();
103. }
104. //invalidrequest
105. returnerror.getMessage();
107. default:
108. returncontext.getResources().getString(
109. R.string.generic_server_down);
110. }
111. }
112. returncontext.getResources().getString(R.string.generic_error);
113. }
114. }

以上代码中引用的xml是：

[html] view plain copy

1. <stringname="no_internet">无网络连接~！</string>
2. <stringname="generic_server_down">连接服务器失败~！</string>
3. <stringname="generic_error">网络异常,请稍后再试~！</string>

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

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

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

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

因为Volley需要从这些头信息判断缓存是否已经过期。如果已经过期Volley将会重新从网络获取数据。

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

可以支持缓存的头信息

2.如果我们自己写一个网络请求框架，我们内部实现会选择使用HttpURLConnection还是HttpClient？

我们通过源码来看看Volley是如何选择使用的

[java] view plain copy

1. publicstaticRequestQueuenewRequestQueue(Contextcontext,HttpStackstack){
2. FilecacheDir=newFile(context.getCacheDir(),DEFAULT_CACHE_DIR);
3. StringuserAgent="volley/0";
4. try{
5. StringpackageName=context.getPackageName();
6. PackageInfoinfo=context.getPackageManager().getPackageInfo(packageName,0);
7. userAgent=packageName+"/"+info.versionCode;
8. }catch(NameNotFoundExceptione){
9. }
10. if(stack==null){
11. if(Build.VERSION.SDK_INT>=9){
12. stack=newHurlStack();
13. }else{
14. stack=newHttpClientStack(AndroidHttpClient.newInstance(userAgent));
15. }
16. }
17. Networknetwork=newBasicNetwork(stack);
18. RequestQueuequeue=newRequestQueue(newDiskBasedCache(cacheDir),network);
19. queue.start();
20. returnqueue;
21. }

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

从这点我们可以学习到，要针对不同SDK版本做去相应更优的处理方式，这样才能达到最好的效果。

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

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

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

[java] view plain copy

1. publicclassNetworkImageViewextendsImageView{
2. privateStringmUrl;
4. //默认显示的图片
5. privateintmDefaultImageId;
7. //加载失败时显示的图片
8. privateintmErrorImageId;
10. //主方法入口
11. publicvoidsetImageUrl(Stringurl,ImageLoaderimageLoader){
12. mUrl=url;
13. mImageLoader=imageLoader;
14. //这个方法将会对ImageView的尺寸是否有效、是否为同一张图片进行判断
15. //在执行新请求前，也会取消上一次在这个View里启动的另一个已经失效的请求
16. //由于篇幅的限制以及代码行数太多，这里不贴出具体实现的代码
17. loadImageIfNecessary(false);
18. }
20. //如果图片已经滑离屏幕，变为不可见，将执行取消请求的操作
21. @Override
22. protectedvoidonDetachedFromWindow(){
23. if(mImageContainer!=null)mImageContainer.cancelRequest();
24. super.onDetachedFromWindow();
25. }
26. }

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

更多相关文章

1. Android(安卓)Volloy 网络请求框架图
2. Android调用系统分享功能总结
3. 【Android】ListView RecyclerView
4. Android图形图画学习(5)——解码图片
5. Android(安卓)ImageView.ScaleType设置图解
6. android 在你的UI中显示Bitmap - 开发文档翻译
7. android-image-slide-panel图片照片墙的加载和滑动特效
8. Android多点触控实现图片自由缩放
9. Android不能进行http请求，https无法抓包的解决

随机推荐

1. 实时Android语音对讲系统架构
2. Android(安卓)模块化编程之引用本地的aar
3. Android(安卓)Drawable系列（1）：自定义背景以
4. android – 多屏幕适配相关
5. Android数据绑定Data Binding初体验
6. Android源码阅读分析：ActivityManagerServ
7. Android(安卓)Studio部署apk到手机后手机
8. Android不同分辨率适配
9. Android界面与交互设计原则（Android(安卓)
10. Android(安卓)软键盘弹出时布局位置改变