[Android]Volley的使用

Volley是Google I/O 2013上提出来的为Android提供简单快速网络访问的项目。Volley特别适合数据量不大但是通信频繁的场景。

优势

相比其他网络载入类库，Volley 的优势官方主要提到如下几点：

  1. 队列网络请求，并自动合理安排何时去请求。
  2. 提供了默认的磁盘和内存等缓存(Disk Caching & Memory Caching)选项。
  3. Volley 可以做到高度自定义，它能做到的不仅仅是缓存图片等资源。
  4. Volley 相比其他的类库更方便调试和跟踪。

资料：

0. https://www.captechconsulting.com/blog/raymond-robinson/google-io-2013-volley-image-cache-tutorial

1. Asynchronous HTTP Requests in Android Using Volley

http://www.it165.net/pro/html/201310/7419.html 

作者：张兴业  发布日期：2013-10-09 22:16:03

Volley是Android开发者新的瑞士军刀，它提供了优美的框架，使得Android应用程序网络访问更容易和更快。 Volley抽象实现了底层的HTTP Client库，让你不关注HTTP Client细节，专注于写出更加漂亮、干净的RESTful HTTP请求。另外，Volley请求会异步执行，不阻挡主线程。

Volley提供的功能

简单的讲，提供了如下主要的功能：

1、封装了的异步的RESTful 请求API；

2、一个优雅和稳健的请求队列；

3、一个可扩展的架构，它使开发人员能够实现自定义的请求和响应处理机制；

4、能够使用外部HTTP Client库；

5、缓存策略；

6、自定义的网络图像加载视图（NetworkImageView，ImageLoader等);

为什么使用异步HTTP请求？

Android中要求HTTP请求异步执行，如果在主线程执行HTTP请求，可能会抛出android.os.NetworkOnMainThreadException 异常。阻塞主线程有一些严重的后果，它阻碍UI渲染，用户体验不流畅，它可能会导致可怕的ANR（Application Not Responding）。要避免这些陷阱，作为一个开发者，应该始终确保HTTP请求是在一个不同的线程。

怎样使用Volley

这篇博客将会详细的介绍在应用程程中怎么使用volley，它将包括一下几方面：

1、安装和使用Volley库

2、使用请求队列

3、异步的JSON、String请求

4、取消请求

5、重试失败的请求，自定义请求超时

6、设置请求头（HTTP headers）

7、使用Cookies

8、错误处理

安装和使用Volley库

引入Volley非常简单，首先，从git库先克隆一个下来：

view sourceprint?
1.git clone https://android.googlesource.com/platform/frameworks/volley

然后编译为jar包，再把jar包放到自己的工程的libs目录。
 

使用请求队列

Volley的所有请求都放在一个队列，然后进行处理，这里是你如何将创建一个请求队列：

view sourceprint?
1.RequestQueue mRequestQueue = Volley.newRequestQueue(this); // 'this' is Context

理想的情况是把请求队列集中放到一个地方，最好是初始化应用程序类中初始化请求队列，下面类做到了这一点：
 

view sourceprint?
01.public class ApplicationController extends Application {
02. 
03./**
04.* Log or request TAG
05.*/
06.public static final String TAG = "VolleyPatterns";
07. 
08./**
09.* Global request queue for Volley
10.*/
11.private RequestQueue mRequestQueue;
12. 
13./**
14.* A singleton instance of the application class for easy access in other places
15.*/
16.private static ApplicationController sInstance;
17. 
18.@Override
19.public void onCreate() {
20.super.onCreate();
21. 
22.// initialize the singleton
23.sInstance = this;
24.}
25. 
26./**
27.* @return ApplicationController singleton instance
28.*/
29.public static synchronized ApplicationController getInstance() {
30.return sInstance;
31.}
32. 
33./**
34.* @return The Volley Request queue, the queue will be created if it is null
35.*/
36.public RequestQueue getRequestQueue() {
37.// lazy initialize the request queue, the queue instance will be
38.// created when it is accessed for the first time
39.if (mRequestQueue == null) {
40.mRequestQueue = Volley.newRequestQueue(getApplicationContext());
41.}
42. 
43.return mRequestQueue;
44.}
45. 
46./**
47.* Adds the specified request to the global queue, if tag is specified
48.* then it is used else Default TAG is used.
49.*
50.* @param req
51.* @param tag
52.*/
53.public <T> void addToRequestQueue(Request<T> req, String tag) {
54.// set the default tag if tag is empty
55.req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);
56. 
57.VolleyLog.d("Adding request to queue: %s", req.getUrl());
58. 
59.getRequestQueue().add(req);
60.}
61. 
62./**
63.* Adds the specified request to the global queue using the Default TAG.
64.*
65.* @param req
66.* @param tag
67.*/
68.public <T> void addToRequestQueue(Request<T> req) {
69.// set the default tag if tag is empty
70.req.setTag(TAG);
71. 
72.getRequestQueue().add(req);
73.}
74. 
75./**
76.* Cancels all pending requests by the specified TAG, it is important
77.* to specify a TAG so that the pending/ongoing requests can be cancelled.
78.*
79.* @param tag
80.*/
81.public void cancelPendingRequests(Object tag) {
82.if (mRequestQueue != null) {
83.mRequestQueue.cancelAll(tag);
84.}
85.}
86.}

异步的JSON、String请求

Volley提供了以下的实用工具类进行异步HTTP请求：

  • JsonObjectRequest — To send and receive JSON Object from the Server
  • JsonArrayRequest — To receive JSON Array from the Server
  • StringRequest — To retrieve response body as String (ideally if you intend to parse the response by yourself)

JsonObjectRequest

这个类可以用来发送和接收JSON对象。这个类的一个重载构造函数允许设置适当的请求方法（DELETE，GET，POST和PUT）。如果您正在使用一个RESTful服务端，可以使用这个类。下面的示例显示如何使GET和POST请求。
 

GET请求：

view sourceprint?
01.final String URL = "/volley/resource/12";
02.// pass second argument as "null" for GET requests
03.JsonObjectRequest req = new JsonObjectRequest(URL, null,
04.new Response.Listener<JSONObject>() {
05.@Override
06.public void onResponse(JSONObject response) {
07.try {
08.VolleyLog.v("Response:%n %s", response.toString(4));
09.} catch (JSONException e) {
10.e.printStackTrace();
11.}
12.}
13.}, new Response.ErrorListener() {
14.@Override
15.public void onErrorResponse(VolleyError error) {
16.VolleyLog.e("Error: ", error.getMessage());
17.}
18.});
19. 
20.// add the request object to the queue to be executed
21.ApplicationController.getInstance().addToRequestQueue(req);

POST请求：

 

view sourceprint?
01.final String URL = "/volley/resource/12";
02.// Post params to be sent to the server
03.HashMap<String, String> params = new HashMap<String, String>();
04.params.put("token", "AbCdEfGh123456");
05. 
06.JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),
07.new Response.Listener<JSONObject>() {
08.@Override
09.public void onResponse(JSONObject response) {
10.try {
11.VolleyLog.v("Response:%n %s", response.toString(4));
12.} catch (JSONException e) {
13.e.printStackTrace();
14.}
15.}
16.}, new Response.ErrorListener() {
17.@Override
18.public void onErrorResponse(VolleyError error) {
19.VolleyLog.e("Error: ", error.getMessage());
20.}
21.});
22. 
23.// add the request object to the queue to be executed
24.ApplicationController.getInstance().addToRequestQueue(req);

JsonArrayRequest

这个类可以用来接受 JSON Arrary，不支持JSON Object。这个类现在只支持 HTTP GET。由于支持GET，你可以在URL的后面加上请求参数。类的构造函数不支持请求参数。

view sourceprint?
01.final String URL = "/volley/resource/all?count=20";
02.JsonArrayRequest req = new JsonArrayRequest(URL, new Response.Listener<JSONArray> () {
03.@Override
04.public void onResponse(JSONArray response) {
05.try {
06.VolleyLog.v("Response:%n %s", response.toString(4));
07.} catch (JSONException e) {
08.e.printStackTrace();
09.}
10.}
11.}, new Response.ErrorListener() {
12.@Override
13.public void onErrorResponse(VolleyError error) {
14.VolleyLog.e("Error: ", error.getMessage());
15.}
16.});
17. 
18.// add the request object to the queue to be executed
19.ApplicationController.getInstance().addToRequestQueue(req);

StringRequest

这个类可以用来从服务器获取String，如果想自己解析请求响应可以使用这个类，例如返回xml数据。它还可以使用重载的构造函数定制请求。

view sourceprint?
01.final String URL = "/volley/resource/recent.xml";
02.StringRequest req = new StringRequest(URL, new Response.Listener<String>() {
03.@Override
04.public void onResponse(String response) {
05.VolleyLog.v("Response:%n %s", response);
06.}
07.}, new Response.ErrorListener() {
08.@Override
09.public void onErrorResponse(VolleyError error) {
10.VolleyLog.e("Error: ", error.getMessage());
11.}
12.});
13. 
14.// add the request object to the queue to be executed
15.ApplicationController.getInstance().addToRequestQueue(req);

取消请求

Volley提供了强大的API取消未处理或正在处理的请求。取消请求最简单的方法是调用请求队列cancelAll（tag）的方法，前提是你在添加请求时设置了标记。这样就能使标签标记的请求挂起。


给请求设置标签：

view sourceprint?
1.request.setTag("My Tag");

使用ApplicationController添加使用了标签的请求到队列中：

 

view sourceprint?
1.ApplicationController.getInstance().addToRequestQueue(request, "My Tag");


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

 

view sourceprint?
1.mRequestQueue.cancelAll("My Tag");

重试失败的请求，自定义请求超时

Volley中没有指定的方法来设置请求超时时间，可以设置RetryPolicy 来变通实现。DefaultRetryPolicy类有个initialTimeout参数，可以设置超时时间。要确保最大重试次数为1，以保证超时后不重新请求。

Setting Request Timeout

1

request.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));
 

如果你想失败后重新请求（因超时），您可以指定使用上面的代码，增加重试次数。注意最后一个参数，它允许你指定一个退避乘数可以用来实现“指数退避”来从RESTful服务器请求数据。

设置请求头（HTTP headers）

有时候需要给HTTP请求添加额外的头信息，一个常用的例子是添加 “Authorization”到HTTP 请求的头信息。Volley请求类提供了一个 getHeaers（）的方法，重载这个方法可以自定义HTTP 的头信息。

添加头信息：

view sourceprint?
01.JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),
02.new Response.Listener<JSONObject>() {
03.@Override
04.public void onResponse(JSONObject response) {
05.// handle response
06.}
07.}, new Response.ErrorListener() {
08.@Override
09.public void onErrorResponse(VolleyError error) {
10.// handle error                       
11.}
12.}) {
13. 
14.@Override
15.public Map<String, String> getHeaders() throws AuthFailureError {
16.HashMap<String, String> headers = new HashMap<String, String>();
17.headers.put("CUSTOM_HEADER", "Yahoo");
18.headers.put("ANOTHER_CUSTOM_HEADER", "Google");
19.return headers;
20.}
21.};

使用Cookies

Volley中没有直接的API来设置cookies，Volley的设计理念就是提供干净、简洁的API来实现RESTful HTTP请求，不提供设置cookies是合理的。

下面是修改后的ApplicationController类，这个类修改了getRequestQueue()方法，包含了 设置cookie方法，这些修改还是有些粗糙。

view sourceprint?
01.// http client instance
02.private DefaultHttpClient mHttpClient;
03.public RequestQueue getRequestQueue() {
04.// lazy initialize the request queue, the queue instance will be
05.// created when it is accessed for the first time
06.if (mRequestQueue == null) {
07.// Create an instance of the Http client.
08.// We need this in order to access the cookie store
09.mHttpClient = new DefaultHttpClient();
10.// create the request queue
11.mRequestQueue = Volley.newRequestQueue(this, new HttpClientStack(mHttpClient));
12.}
13.return mRequestQueue;
14.}
15. 
16./**
17.* Method to set a cookie
18.*/
19.public void setCookie() {
20.CookieStore cs = mHttpClient.getCookieStore();
21.// create a cookie
22.cs.addCookie(new BasicClientCookie2("cookie", "spooky"));
23.}
24. 
25. 
26.// add the cookie before adding the request to the queue
27.setCookie();
28. 
29.// add the request to the queue
30.mRequestQueue.add(request);

错误处理

正如前面代码看到的，在创建一个请求时，需要添加一个错误监听onErrorResponse。如果请求发生异常，会返回一个VolleyError实例。

以下是Volley的异常列表：

AuthFailureError：如果在做一个HTTP的身份验证，可能会发生这个错误。

NetworkError：Socket关闭，服务器宕机，DNS错误都会产生这个错误。

NoConnectionError：和NetworkError类似，这个是客户端没有网络连接。

ParseError：在使用JsonObjectRequest或JsonArrayRequest时，如果接收到的JSON是畸形，会产生异常。

SERVERERROR：服务器的响应的一个错误，最有可能的4xx或5xx HTTP状态代码。

TimeoutError：Socket超时，服务器太忙或网络延迟会产生这个异常。默认情况下，Volley的超时时间为2.5秒。如果得到这个错误可以使用RetryPolicy。

可以使用一个简单的Help类根据这些异常提示相应的信息：
 

view sourceprint?
01.public class VolleyErrorHelper {
02./**
03.* Returns appropriate message which is to be displayed to the user
04.* against the specified error object.
05.*
06.* @param error
07.* @param context
08.* @return
09.*/
10.public static String getMessage(Object error, Context context) {
11.if (error instanceof TimeoutError) {
12.return context.getResources().getString(R.string.generic_server_down);
13.}
14.else if (isServerProblem(error)) {
15.return handleServerError(error, context);
16.}
17.else if (isNetworkProblem(error)) {
18.return context.getResources().getString(R.string.no_internet);
19.}
20.return context.getResources().getString(R.string.generic_error);
21.}
22. 
23./**
24.* Determines whether the error is related to network
25.* @param error
26.* @return
27.*/
28.private static boolean isNetworkProblem(Object error) {
29.return (error instanceof NetworkError) || (error instanceof NoConnectionError);
30.}
31./**
32.* Determines whether the error is related to server
33.* @param error
34.* @return
35.*/
36.private static boolean isServerProblem(Object error) {
37.return (error instanceof ServerError) || (error instanceof AuthFailureError);
38.}
39./**
40.* Handles the server error, tries to determine whether to show a stock message or to
41.* show a message retrieved from the server.
42.*
43.* @param err
44.* @param context
45.* @return
46.*/
47.private static String handleServerError(Object err, Context context) {
48.VolleyError error = (VolleyError) err;
49. 
50.NetworkResponse response = error.networkResponse;
51. 
52.if (response != null) {
53.switch (response.statusCode) {
54.case 404:
55.case 422:
56.case 401:
57.try {
58.// server might return error like this { "error": "Some error occured" }
59.// Use "Gson" to parse the result
60.HashMap<String, String> result = new Gson().fromJson(new String(response.data),
61.new TypeToken<Map<String, String>>() {
62.}.getType());
63. 
64.if (result != null && result.containsKey("error")) {
65.return result.get("error");
66.}
67. 
68.} catch (Exception e) {
69.e.printStackTrace();
70.}
71.// invalid request
72.return error.getMessage();
73. 
74.default:
75.return context.getResources().getString(R.string.generic_server_down);
76.}
77.}
78.return context.getResources().getString(R.string.generic_error);
79.}
80.}
总结：

Volley是一个非常好的库，你可以尝试使用一下，它会帮助你简化网络请求，带来更多的益处。

我也希望更加全面的介绍Volley，以后可能会介绍使用volley加载图像的内容，欢迎关注。

谢谢你的阅读，希望你能喜欢。

2. [译]Google　I/O 2013:Volley 图片缓存教程

http://www.inferjay.com/blog/2013/08/03/google-i-o-2013-volley-image-cache-tutorial/  Inferjay的技术博客

Gooogle I/O 2013已经结束了，并且对于Android开发的未来它给我们留下了更大的期望。令人非常兴奋的是在今年的I/O大会上展示了一个叫Volley的库。Volley是一个处理和缓存网络请求的库，减少开发人员在实际的每一个应用中写同样的样板代码。写样板代码是很无聊的并且也增加了开发人员出错的几率。Google是出于这些考虑创建了Volley。

如果你还没有看过Gooogle　I/O中关于Volley的介绍，在继续这篇文章之前我建议你先去看看关于Volley的介绍，对它有一些基本的理解。

在Google I/O介绍的时候，Ficus Kirpatrick讲了很多关于Volley如何的有助于图片加载。你会发现在Volley作为你的图片加载解决方案的时候，虽然Volley自己处理了L2的缓存，它需要但是没有包含L1的缓存。许多人会使用像Universal Image Loader或者Square`s newer Picasso这些第三方的库去处理图片的加载；然而这些库通常已经同时处理了图片的加载和缓存。所以，我们如何使用Volley来替换图片的加载和缓存呢？首先，让我们看看Volley提供的便利的加载方法，我们稍后再看他们的不同之处。

ImageLoader

ImageLoader这个类需要一个Request的实例以及一个ImageCache的实例。图片通过一个URL和一个ImageListener实例的get()方法就可以被加载。从哪里，ImageLoader会检查ImageCache,而且如果缓存里没有图片就会从网络上获取。

NetworkImageView

这个类在布局文件中替换ImageViews，并且将使用ImageLoader。NetworkImageView的setUrl()这个方法需要一个字符串的URL路径以及一个ImageLoader的实例。然后它使用ImageLoader的get()方法获取图片数据。

1
2
3
4
5
6
7
8

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/twitterUserImage"
    android:layout_alignParentLeft="true"
    android:layout_alignParentTop="true"
    android:layout_width="40dp"
    android:layout_height="40dp"
    android:padding="5dp"
    />

ImageCache

Volley的ImageCache接口允许你使用你喜欢的L1缓存实现。不幸的是Volley没有提供默认的实现。在I/O的介绍中展示了BitmapLruCache的一点代码片段，但是Volley这个库本身并不包含任何相关的实现。

ImageCache接口有两个方法，getBitmap(String url)和putBitmap(String url, Bitmap bitmap).这两个方法足够简单直白，他们可以添加任何的缓存实现。

在Volley中添加图片缓存

对于这个例子，我创建了一个简单的应用，它从Twitter上搜索提取“CapTech”这个词的推文，并且把包含这个词的推文的用户名和照片显示在一个ListView中，在你滑动这个列表的时候将自动加载以前的记录，并根据需要从缓存中拉取图片。

alt text

例子里有２个可用的缓存实现。一个基于内存的LRU缓存。对于磁盘缓存实现我选择使用由Jake Wharton写的DiskLruCache。我只所以选择这个实现是因为他在Android社区中被经常使用和推荐的并且有一些人试图去改进它。使用一个基于磁盘的L1缓存有可能导致i/o阻塞的问题。Volley已经内置了一个磁盘L2缓存。磁盘L1缓存包括在内了，由于我原来不知道Volley是如何处理图片请求缓存的。

在这个例子中主要的组件实现如下:

RequestManager

RequestManager维护了我们的一个RequestQueue的引用。Volley使用RequestQueue不仅处理了我们给Twitter的数据请求，而且也处理了我的的图片加载。

RequestQueue

这个类虽然跟图片加载没有直接的关系，但是它是具有代表性，它是如何继承Volley的Request类去处理你的JSON解析。它使用GET请求到Twtter并获取TwitterData对象。

BitmapLruImageCache

这是一个基于“least recently used(最近最少使用算法,简称LRU)”内存缓存实现。它是快速的并且不会引起I/O阻塞的。推荐这种方法。

DiskLruImageCache

DiskLruImageCache是一个DiskLruCache和bitmap-centered的包装实现。它从DiskLruCache中获取和添加bitmaps，并且处理缓存的实例。一个磁盘缓存或许会引起I/O的阻塞。

ImageCacheManager

ImageCacheManager持有一个我们的ImageCache和Volley ImageLoader的引用。

有一件事情你要注意，在ImageCacheManager中我们使用了字符串URL的hashCode()值作为缓存的Key。这么做是因为在URL中的某些字符不能作为缓存的Key。

BuzzArrayAdapter

这是一个简单的Adapter。这里唯一要注意的是我们实现了Volley的Listener和ErrListener接口并且将这个 Adapter作为 NetworkImageView’s的setUrl(String string , Listener listener, ErrorListener errorListener) 方法的Listener。这个Adapter还有一点额外的代码，用来在滚动的时候加载老的推文。

1
2
3
4
5
6
7
8

Tweet tweet = mData.get(position);
if(tweet != null){
viewHolder.twitterUserImage.setImageUrl(tweet.getUserImageUrl(),ImageCacheManager.getInstance().getImageLoader());
	viewHolder.userNameTextView.setText("@" + tweet.getUsername());
	viewHolder.messageTextView.setText(tweet.getMessage());
	viewHolder.tweetTimeTextView.setText(formatDisplayDate(tweet.getCreatedDate()));
	viewHolder.destinationUrl = tweet.getDestinationUrl();
}

Putting it all together

把这些组件组合在一起，图片加载和缓存是如此的简单。在启动时，在MainApplication这个类中初始化RequestManager和ImageCacheManager。在那里你可以定义你想要的L1缓存类型。内存缓存是默认的。

在MainActivity中我们调用TwitterManager并且加载我们的的初始数据集。一旦我们接收到响应我们就把这个响应传递给一个BuzzArrayAdapter并把这个Adapter设置到我们的ListView上。

正如我们已经在上面看到了BuzzArrayAdapter的代码,对于NetworkImageView所有繁重的图片加载操作我们仅仅需要从我们的ImageCacheManager中获取一个ImageLoader的实例传递给它就可以了。

ImageCacheManager会检查我的LRU缓存实现并且如果这个图片是可用的就会返回它。如果这个图片不在在缓存中那么就从网络获取它。

当你滚动ListView的时候BuzzArrayAdapter将一起加载额外的推文和图片，并且重用在缓存中已经存在的图片。

Closing Thoughts on Volley

虽然Volley是好用的，快速的，很容易实现的；但他也有一些不足的地方:

  • 这个库没有任何的文档和例子。
  • 比如缓存配置组件，他们为什么不做成可配置的。
  • 从以上可以看出，除了一个比较奇怪的基本图片缓存实现以外,它甚至可能有使用NoImageCache的实现,或者在缓存完全可选的时候，你只是想从网络上获取任何东西。

关于Volley在开发者社区中有很多令人激动的事情，并且有很的好的理由。感觉它就像一个库，它包含了一部分旧的Android API.像在I/O上公布的新的定位API,它是非常纯净的~~~~

Github上的例子源码

VolleyImageCacheExample

附件:

VolleyImageCacheExample-master.zip

原文作者:

Trey Robinson

原文地址:

http://blogs.captechconsulting.com/blog/raymond-robinson/google-io-2013-volley-image-cache-tutorial

关于本文

前端时间偶然间看到了Volley，最近开始做一个新项目又重新去看了看I/O中关于Volley的介绍,感觉Volley很牛逼，于是就想在新项目中试试Volley,找来找去关于Volley的 资料几乎没有，在Google中找到了这篇文章，看了觉得不错，于是就决定翻译一下，一来加深自己的理解，二来呢顺便补一下自己那惨不忍睹的英语。由于本 人英语水平比较烂，翻译的时候有可能会曲解原作者的意思，建议英语好的大牛飘过此文去看作者的原文，欢迎大家吐槽和拍砖，觉得译文中有那些地方我翻译的不 妥的地方欢迎回复指正，我们相互学习～～～

声明

转载须以超链接形式标明文章原始出处和作者信息及版权声明.

3. Android开源框架Volley(Google IO 2013)源代码及内部实现分析

http://my.oschina.net/u/1420982/blog/184209

1.Volley概述

在项目开发过程中，博主曾写过大量的访问网络重复代码，特别是ListView adapter很难避免getView()方法不被重复调用，如果ImageView不利用缓存机制，那么网络的负荷就会更大！曾将访问网络代码和缓存封 装起来使用，但是中间仍存在不少瑕疵！今年的Google I/O 2013上，Volley发布了！Volley是Android平台上的网络通信库，能使网络通信更快，更简单，更健壮

SouthEast.jpg (145.72 KB, 下载次数: 0)

下载附件  保存到相册

昨天 16:24 上传

 

Volley特别适合数据量不大但是通信频繁的场景，现在android提供的源码已经包含Volley，以后在项目中，可以根据需求引入Volley jar文件！

2.Volley源码分析 (1).Volley.java Volley.newRequestQueue()方法在一个app最好执行一次，可以使用单例设计模式或者在application完成初始化，具体原因请查看代码分析

  1. /**
  2. * @author zimo2013
  3. * [url=home.php?mod=space&uid=189949]@See[/url] http://blog.csdn.net/zimo2013
  4. */
  5. public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
  6.     File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

  8.     String userAgent = "volley/0";
  9.     try {
  10.         String packageName = context.getPackageName();
  11.         PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
  12.         userAgent = packageName + "/" + info.versionCode;
  13.     } catch (NameNotFoundException e) {
  14.     }

  16.     if (stack == null) {
  17.         if (Build.VERSION.SDK_INT >= 9) {
  18.             stack = new HurlStack();
  19.         } else {
  20.             stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
  21.         }
  22.     }

  24.     Network network = new BasicNetwork(stack);

  26.     //cacheDir 缓存路径 /data/data/<pkg name>/cache/<name>
  27.     RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
  28.     queue.start();
  29.     /*
  30.      * 实例化一个RequestQueue，其中start()主要完成相关工作线程的开启，
  31.      * 比如开启缓存线程CacheDispatcher先完成缓存文件的扫描， 还包括开启多个NetworkDispatcher访问网络线程，
  32.      * 该多个网络线程将从 同一个 网络阻塞队列中读取消息
  33.      *
  34.      * 此处可见，start()已经开启，所有我们不用手动的去调用该方法，在start()方法中如果存在工作线程应该首先终止，并重新实例化工作线程并开启
  35.      * 在访问网络很频繁，而又重复调用start()，势必会导致性能的消耗；但是如果在访问网络很少时，调用stop()方法，停止多个线程，然后调用start(),反而又可以提高性能，具体可折中选择
  36.      */

  38.     return queue;
  39. }
复制代码


(2).RequestQueue.java

  1. /**
  2. * RequestQueue类存在2个非常重要的PriorityBlockingQueue类型的成员字段mCacheQueue mNetworkQueue ，该PriorityBlockingQueue为java1.5并发库提供的新类
  3. * 其中有几个重要的方法，比如take()为从队列中取得对象，如果队列不存在对象，将会被阻塞，直到队列中存在有对象，类似于Looper.loop()
  4. *
  5. * 实例化一个request对象，调用RequestQueue.add(request),该request如果不允许被缓存，将会被添加至mNetworkQueue队列中，待多个NetworkDispatcher线程take()取出对象
  6. * 如果该request可以被缓存，该request将会被添加至mCacheQueue队列中，待mCacheDispatcher线程从mCacheQueue.take()取出对象，
  7. * 如果该request在mCache中不存在匹配的缓存时，该request将会被移交添加至mNetworkQueue队列中，待网络访问完成后，将关键头信息添加至mCache缓存中去！
  8. *
  9. * @author zimo2013
  10. * @see http://blog.csdn.net/zimo2013
  11. */
  12. public void start() {
  13.     stop();
  14.    
  15.     mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
  16.     mCacheDispatcher.start();

  18.     // Create network dispatchers (and corresponding threads) up to the pool size.
  19.     for (int i = 0; i < mDispatchers.length; i++) {
  20.         NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
  21.                 mCache, mDelivery);
  22.         mDispatchers[i] = networkDispatcher;
  23.         networkDispatcher.start();
  24.     }
  25. }
复制代码


(3).CacheDispatcher.java

  1. /**
  2. * @author zimo2013
  3. * @see http://blog.csdn.net/zimo2013
  4. */
  5. @Override
  6. public void run() {
  7.     Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

  9.     //缓存初始化，会遍历整个缓存文件夹
  10.     mCache.initialize();
  11.     {
  12.             //执行代码
  13.             /*if (!mRootDirectory.exists()) {
  14.             if (!mRootDirectory.mkdirs()) {
  15.                 VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
  16.             }
  17.             return;
  18.         }

  20.         File[] files = mRootDirectory.listFiles();
  21.         if (files == null) {
  22.             return;
  23.         }
  24.         for (File file : files) {
  25.             FileInputStream fis = null;
  26.             try {
  27.                 fis = new FileInputStream(file);
  28.                 CacheHeader entry = CacheHeader.readHeader(fis);
  29.                 entry.size = file.length();
  30.                 putEntry(entry.key, entry);
  31.             } catch (IOException e) {
  32.                 if (file != null) {
  33.                    file.delete();
  34.                 }
  35.             } finally {
  36.                 try {
  37.                     if (fis != null) {
  38.                         fis.close();
  39.                     }
  40.                 } catch (IOException ignored) { }
  41.             }
  42.         }*/
  43.     }

  45.     while (true) {
  46.         try {
  47.                 //该方法可能会被阻塞
  48.             final Request request = mCacheQueue.take();

  50.             Cache.Entry entry = mCache.get(request.getCacheKey());
  51.             if (entry == null) {
  52.                     //缓存不存在，则将该request添加至网络队列中
  53.                 mNetworkQueue.put(request);
  54.                 continue;
  55.             }

  57.             //是否已经过期
  58.             if (entry.isExpired()) {
  59.                 request.setCacheEntry(entry);
  60.                 mNetworkQueue.put(request);
  61.                 continue;
  62.             }

  64.             Response<?> response = request.parseNetworkResponse(
  65.                     new NetworkResponse(entry.data, entry.responseHeaders));

  67.             //存在缓存，执行相关操作

  69.         } catch (InterruptedException e) {
  70.         }
  71.     }
  72. }
复制代码


(4).NetworkDispatcher.java

  1. /**
  2. * @author zimo2013
  3. * @see http://blog.csdn.net/zimo2013
  4. */
  5. @Override
  6. public void run() {
  7.     Request request;
  8.     while (true) {
  9.         try {
  10.                 //可能会被
  11.             request = mQueue.take();
  12.         } catch (InterruptedException e) {
  13.             // We may have been interrupted because it was time to quit.
  14.             if (mQuit) {
  15.                 return;
  16.             }
  17.             continue;
  18.         }

  20.         try {
  21.                
  22.                 //访问网络，得到数据
  23.             NetworkResponse networkResponse = mNetwork.performRequest(request);

  25.             if (networkResponse.notModified && request.hasHadResponseDelivered()) {
  26.                 request.finish("not-modified");
  27.                 continue;
  28.             }

  30.             // Parse the response here on the worker thread.
  31.             Response<?> response = request.parseNetworkResponse(networkResponse);

  33.             // 写入缓存
  34.             if (request.shouldCache() && response.cacheEntry != null) {
  35.                 mCache.put(request.getCacheKey(), response.cacheEntry);
  36.                 request.addMarker("network-cache-written");
  37.             }

  39.             // Post the response back.
  40.             request.markDelivered();
  41.             mDelivery.postResponse(request, response);
  42.         } catch (VolleyError volleyError) {
  43.             parseAndDeliverNetworkError(request, volleyError);
  44.         } catch (Exception e) {
  45.             VolleyLog.e(e, "Unhandled exception %s", e.toString());
  46.             mDelivery.postError(request, new VolleyError(e));
  47.         }
  48.     }
  49. }
复制代码


(5).StringRequest.java

其中在parseNetworkResponse()中，完成将byte[]到String的转化,可能会出现字符乱 码，HttpHeaderParser.parseCharset(response.headers)方法在尚未指定是返回为ISO-8859-1，可 以修改为 utf-8
  1. public class StringRequest extends Request<String> {
  2.     private final Listener<String> mListener;

  4.     /**
  5.      * Creates a new request with the given method.
  6.      *
  7.      * @param method the request {@link Method} to use
  8.      * @param url URL to fetch the string at
  9.      * @param listener Listener to receive the String response
  10.      * @param errorListener Error listener, or null to ignore errors
  11.      */
  12.     public StringRequest(int method, String url, Listener<String> listener,
  13.             ErrorListener errorListener) {
  14.         super(method, url, errorListener);
  15.         mListener = listener;
  16.     }

  18.     public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
  19.         this(Method.GET, url, listener, errorListener);
  20.     }

  22.     @Override
  23.     protected void deliverResponse(String response) {
  24.         mListener.onResponse(response);
  25.     }

  27.     @Override
  28.     protected Response<String> parseNetworkResponse(NetworkResponse response) {
  29.         String parsed;
  30.         try {
  31.                 //将data字节数据转化为String对象
  32.             parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
  33.         } catch (UnsupportedEncodingException e) {
  34.             parsed = new String(response.data);
  35.         }
  36.         //返回Response对象，其中该对象包含访问相关数据
  37.         return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
  38.     }
  39. }
复制代码


(6).ImageLoader.java

  1. /**
  2. * @author zimo2013
  3. * @see http://blog.csdn.net/zimo2013
  4. */
  5. public ImageContainer get(String requestUrl, ImageListener imageListener,
  6.         int maxWidth, int maxHeight) {
  7.     throwIfNotOnMainThread();
  8.     final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);

  10.     //从mCache得到bitmap对象，因此可以覆写ImageCache，完成图片的三级缓存，即在原有的LruCache添加一个软引用缓存
  11.     Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
  12.     if (cachedBitmap != null) {
  13.             //得到缓存对象
  14.         ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
  15.         imageListener.onResponse(container, true);
  16.         return container;
  17.     }

  19.     ImageContainer imageContainer =
  20.             new ImageContainer(null, requestUrl, cacheKey, imageListener);

  22.     // 首先更新该view，其指定了defaultImage
  23.     imageListener.onResponse(imageContainer, true);

  25.     // 根据可以去检查该请求是否已经发起过
  26.     BatchedImageRequest request = mInFlightRequests.get(cacheKey);
  27.     if (request != null) {
  28.         request.addContainer(imageContainer);
  29.         return imageContainer;
  30.     }

  32.     Request<?> newRequest =
  33.         new ImageRequest(requestUrl, new Listener<Bitmap>() {
  34.             @Override
  35.             public void onResponse(Bitmap response) {
  36.                     //如果请求成功
  37.                 onGetImageSuccess(cacheKey, response);
  38.             }
  39.         }, maxWidth, maxHeight,
  40.         Config.RGB_565, new ErrorListener() {
  41.             @Override
  42.             public void onErrorResponse(VolleyError error) {
  43.                 onGetImageError(cacheKey, error);
  44.             }
  45.         });
  46.     //添加至请求队列中
  47.     mRequestQueue.add(newRequest);
  48.     //同一添加进map集合，以方便检查该request是否正在请求网络，可以节约资源
  49.     mInFlightRequests.put(cacheKey, new BatchedImageRequest(newRequest, imageContainer));
  50.     return imageContainer;
  51. }
复制代码
  1. private void onGetImageSuccess(String cacheKey, Bitmap response) {
  2.         //缓存对象
  3.     mCache.putBitmap(cacheKey, response);

  5.     // 请求完成，不需要检测
  6.     BatchedImageRequest request = mInFlightRequests.remove(cacheKey);

  8.     if (request != null) {
  9.         request.mResponseBitmap = response;
  10.         //处理结果
  11.         batchResponse(cacheKey, request);
  12.     }
  13. }
复制代码
  1. private void batchResponse(String cacheKey, BatchedImageRequest request) {
  2.     mBatchedResponses.put(cacheKey, request);
  3.     //通过handler，发送一个操作
  4.     if (mRunnable == null) {
  5.         mRunnable = new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 for (BatchedImageRequest bir : mBatchedResponses.values()) {
  9.                     for (ImageContainer container : bir.mContainers) {
  10.                         if (container.mListener == null) {
  11.                             continue;
  12.                         }
  13.                         if (bir.getError() == null) {
  14.                             container.mBitmap = bir.mResponseBitmap;
  15.                             //更新结果
  16.                             container.mListener.onResponse(container, false);
  17.                         } else {
  18.                             container.mListener.onErrorResponse(bir.getError());
  19.                         }
  20.                     }
  21.                 }
  22.                 mBatchedResponses.clear();
  23.                 mRunnable = null;
  24.             }

  26.         };
  27.         // mHandler对应的looper是MainLooper，因此被MainLooper.loop()得到该message，故该runnable操作在主线程中执行，
  28.         mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
  29.     }
  30. }
复制代码


3.总结

SouthEast.jpg (187.99 KB, 下载次数: 0)

下载附件  保存到相册

昨天 16:24 上传

 

RequestQueue类存在2个非常重要的PriorityBlockingQueue类型的成员字段mCacheQueue mNetworkQueue ，该PriorityBlockingQueue为java1.5并发库提供的！其中有几个重要的方法，比如take()为从队列中取得对象，如果队列不 存在对象，将会被阻塞，直到队列中存在有对象，类似于Looper.loop()。实例化一个request对象，调用 RequestQueue.add(request),该request如果不允许被缓存，将会被添加至mNetworkQueue队列中，待多个 NetworkDispatcher线程从mNetworkQueue中take()取出对象。如果该request可以被缓存，该request将会被 添加至mCacheQueue队列中，待mCacheDispatcher线程从mCacheQueue.take()取出对象，如果该request在 mCache中不存在匹配的缓存时，该request将会被移交添加至mNetworkQueue队列中，待网络访问完成后，将关键头信息添加至 mCache缓存中去，并通过ResponseDelivery主线程调用request的相关方法！Volley实例
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/spec-dog/p/3723322.html