Android训练课程(Android Training) - 使用Volley传输网络数据（Transmitting Network Data Using Volley）

上节课展示了如何使用 Volley.newRequestQueue 这个便利的方法来设置一个请求队列，以获得Volley提供的默认行为的好处。这节课教你通过明确的几个步骤来创建一个请求队列，使得你可以定制它。

这节课也描述一个推荐的实践方式，使用单例模式创建一个请求队列，这个请求队列会持续整个App的生命周期。

设置一个网络和缓存（Set Up a Network and Cache）

一个请求队列要完成它自己的工作需要两样东西： 一个 network（网络） 对象处理请求的传输，和一个 cache(缓存）对象来处理缓存。在Volley 工具盒 中已经有了里那两个标准的可用的实现： DiskBasedCache提供了一个 “每响应单文件（one-file-per-response）” 的缓存并在内存中建立索引； BasicNetwork对象提供了以 你自己选择的AndroidHttpClient 或 HttpURLConnection 对象 为基础的网络传输。

BasicNetwork 是Volley的默认 network（网络） 实现。一个 BasicNetwork 对象必须先被  使用HTTP客户端 来初始化后才能连接网络。比较有代表性的是AndroidHttpClient or HttpURLConnection:

• 在Android API level 9  (Gingerbread)以下的应用中，使用 AndroidHttpClient 。早于 Gingerbread, HttpURLConnection 是不可靠的. 更多请阅读 Android's HTTP Clients.
• 在Android API level 9  (Gingerbread)及更高版本，使用 HttpURLConnection .

要创建一个可运行在Android全版本的应用，你可用检查Android硬件设备上运行的Android系统的版本号，以做出选择是HTTP 客户端，比如：

HttpStack stack;
...
// If the device is running a version >= Gingerbread...
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
// ...use HttpURLConnection for stack.
} else {
// ...use AndroidHttpClient for stack.
}
Network network = new BasicNetwork(stack);

这个代码片段展示了设置请求队列的步骤：

RequestQueue mRequestQueue;// Instantiate the cache
Cache cache = new DiskBasedCache(getCacheDir(), 1024 * 1024); // 1MB cap// Set up the network to use HttpURLConnection as the HTTP client.
Network network = new BasicNetwork(new HurlStack());// Instantiate the RequestQueue with the cache and network.
mRequestQueue = new RequestQueue(cache, network);// Start the queue
mRequestQueue.start();String url ="http://www.myurl.com";// Formulate the request and handle the response.
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Do something with the response
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// Handle error
}
});// Add the request to the RequestQueue.
mRequestQueue.add(stringRequest);
...

如果你仅仅需要构建单次的请求，并且不想离开线程池的范围，你可用创建在任何地方创建请求队列，和在收到响应或者错误后调用stop()方法，使用Volley.newRequestQueue()的方法可参阅 Sending a Simple Request。但是更多一般的使用情形是 使用单例模式创建请求队列并且让它和你的应用的生命周期一致，更多描述在下一章节。

使用单例模式（Use a Singleton Pattern）

如果你的应用需要经常访问网络，那么配置一个单例模式的请求队列并保持在app的整个生命周期的方式是非常有效率的。你可以有多种方式这样实现。推荐的方式是实现一个单例类来封装请求队列和其他的Volley功能方法/函数。其他的实现方式比如实现 Applicaton的子类并在Application.onCreate()方法中配置请求队列，这样的方式现在是被劝阻的；一个静态的单例能够以模块化的方式提供同样的功能。

一个关键概念是请求队列必须使用Application的context对象来初始化，而不时 Activity的context.这样确保请求队列会持续在整个app的生命周期，而在activity的context的实现会在activity被重新创建时被创建多次（比如，当用户旋转了屏幕就会重新创建activity）。

下面是一个实现了单例模式的类的示例，它提供了请求队列和图片下载器(ImageLoader)的功能:

private static MySingleton mInstance;
private RequestQueue mRequestQueue;
private ImageLoader mImageLoader;
private static Context mCtx; private MySingleton(Context context) {
mCtx = context;
mRequestQueue = getRequestQueue(); mImageLoader = new ImageLoader(mRequestQueue,
new ImageLoader.ImageCache() {
private final LruCache<String, Bitmap>
cache = new LruCache<String, Bitmap>(20); @Override
public Bitmap getBitmap(String url) {
return cache.get(url);
} @Override
public void putBitmap(String url, Bitmap bitmap) {
cache.put(url, bitmap);
}
});
} public static synchronized MySingleton getInstance(Context context) {
if (mInstance == null) {
mInstance = new MySingleton(context);
}
return mInstance;
} public RequestQueue getRequestQueue() {
if (mRequestQueue == null) {
// getApplicationContext() is key, it keeps you from leaking the
// Activity or BroadcastReceiver if someone passes one in.
mRequestQueue = Volley.newRequestQueue(mCtx.getApplicationContext());
}
return mRequestQueue;
} public <T> void addToRequestQueue(Request<T> req) {
getRequestQueue().add(req);
} public ImageLoader getImageLoader() {
return mImageLoader;
}
}

下面是使用单例类处理请求队列操作的示例：

// Get a RequestQueue
RequestQueue queue = MySingleton.getInstance(this.getApplicationContext()).
getRequestQueue();
...// Add a request (in this example, called stringRequest) to your RequestQueue.
MySingleton.getInstance(this).addToRequestQueue(stringRequest);

构建一个标准请求（Making a Standard Request）

这节课描述了如何使用Volley提供的一般请求类型：

• StringRequest. 指定一个网址(URL)和在相应里收到一个原始字符串. 在 Setting Up a Request Queue 有示例.
• ImageRequest. 指定一个网址(URL)和在响应中收到图片.
• JsonObjectRequest 和 JsonArrayRequest (都是 JsonRequest的子类). 指定一个网址(URL)和获得一个JSON 对象或者JSON数组.

如果你期望的响应是上面这些中的一种，你可能不再需要实现自定义的请求。这节课描述了如何使用这些标准请求类型。更多关于自定义请求的内容请阅读Implementing a Custom Request.

请求一个图片（Request an Image）

Volley 提供了下面的类用来请求图片，这些类在它们彼此层次的顶层，提供不同程度的处理图片的支持:

• ImageRequest（图片请求）— 一个封装的请求，用于通过指定的URL获得一个图片和在对图片解码完毕后回调。它还提供了便利的特性比如指定一个将要调整到的尺寸。它非常有利的是，Volley的线程调度确保了昂贵的图片操作（比如解码，改变大小）等自动的在工作线程中执行。
• ImageLoader（图片下载器）— 一个辅助类，处理通过多个远程图片地址加载和缓存图片。ImageLoader是一个处理大量图片请求的控制台，比如在一个ListView中放置多个缩略图。ImageLoader 提供了一个内存缓存，以在Volley一般的缓存之上，对于防止闪烁这是非常重要的。这提供了一个可能性去实现一个缓存的击中，而不会在主线程阻塞或者发生延迟，如果使用 硬盘I/O 是不可能做到的。ImageLoader同时也做了响应合并，没有它，几乎每个响应处理器都会将图片显示在一个视图View上和导致每个图片发生一次布局（layout）操作。合并使得 同时传递多个响应 成为可能，它提升了性能。
• NetworkImageView—  以 ImageLoader为基础和 有效的代替 ImageView 在一些状况下，比如当你的图片通过一个网址在网络中被提取。NetworkImageView也管理着 在一个NetworkImageView被从视图层级中分离时终止等待中的请求。

使用 ImageRequest (Use ImageRequest)

下面是一个使用ImageRequest的示例。它通过一个URL获得图片并在应用中显示。注意这里使用单例模式和请求队里进行的交互。  (更多关于这个话题的讨论请阅读 training/volley/requestqueue.html#singleton">Setting Up a RequestQueue):

ImageView mImageView;
String url = "http://i.imgur.com/7spzG.png";
mImageView = (ImageView) findViewById(R.id.myImage);
...// Retrieves an image specified by the URL, displays it in the UI.
ImageRequest request = new ImageRequest(url,
new Response.Listener() {
@Override
public void onResponse(Bitmap bitmap) {
mImageView.setImageBitmap(bitmap);
}
}, 0, 0, null,
new Response.ErrorListener() {
public void onErrorResponse(VolleyError error) {
mImageView.setImageResource(R.drawable.image_load_error);
}
});
// Access the RequestQueue through your singleton class.
MySingleton.getInstance(this).addToRequestQueue(request);

使用 ImageLoader 和 NetworkImageView（Use ImageLoader and NetworkImageView）

你可以使用 ImageLoader 和 NetworkImageView 协调有效的管理大量图片的显示, 比如在 ListView中.在你的布局 XML 文件中, 使用 NetworkImageView和使用 ImageView 非常相似, 例如:

<com.android.volley.toolbox.NetworkImageView
android:id="@+id/networkImageView"
android:layout_width="150dp"
android:layout_height="170dp"
android:layout_centerHorizontal="true" />

你可以使用 ImageLoader 通过它自己来显示一个图片,例如:

ImageLoader mImageLoader;
ImageView mImageView;
// The URL for the image that is being loaded.
private static final String IMAGE_URL =
"http://developer.android.com/images/training/system-ui.png";
...
mImageView = (ImageView) findViewById(R.id.regularImageView);// Get the ImageLoader through your singleton class.
mImageLoader = MySingleton.getInstance(this).getImageLoader();
mImageLoader.get(IMAGE_URL, ImageLoader.getImageListener(mImageView,
R.drawable.def_image, R.drawable.err_image));

然而, 如果你的操作仅仅是显示图片在 ImageView中的话，那么 NetworkImageView 也可以做到这些你想做到的，例如：

ImageLoader mImageLoader;
NetworkImageView mNetworkImageView;
private static final String IMAGE_URL =
"http://developer.android.com/images/training/system-ui.png";
...// Get the NetworkImageView that will display the image.
mNetworkImageView = (NetworkImageView) findViewById(R.id.networkImageView);// Get the ImageLoader through your singleton class.
mImageLoader = MySingleton.getInstance(this).getImageLoader();// Set the URL of the image that should be loaded into this view, and
// specify the ImageLoader that will be used to make the request.
mNetworkImageView.setImageUrl(IMAGE_URL, mImageLoader);

上面这些代码片段演示了通过一个单例类访问请求队列（RequestQueue）和图片下载（ImageLoader）的方式，更多描述见Setting Up a RequestQueue。这样的方式确保了你创建这些类的单个实例并且持续整个App的生命周期。非常重要的原因是对于ImageLoader（这个帮助类处理读取和缓存图片）来说，内存缓存的主要功能是做到了在翻转屏幕时不闪烁。使用一个单例模式允许位图缓存比activity活得长。如果你在Activity中创建了一个ImageLoader，这个ImageLoader将跟随activity，每次用户翻转设备时都会重新创建而发生屏幕闪烁。

LRU缓存示例(Example LRU cache)

Volley工具盒提供了基于DiskBasedCache类的标准缓存的实现。这个类缓存一个文件直接到硬盘上的指定文件夹。但是要使用ImageDownloader，你需要提供一个自定义的内存 LRU位图缓存并需要实现ImageLoader.ImageCache接口。你可以使用单例类设置你的缓存；更多讨论请阅读 Setting Up a RequestQueue.

下面的LruBitmapCache类是一个实现的示例。它继承自 LruCache 并实现了 ImageLoader.ImageCache interface接口：

import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.util.DisplayMetrics;
import com.android.volley.toolbox.ImageLoader.ImageCache;public class LruBitmapCache extends LruCache<String, Bitmap>
implements ImageCache { public LruBitmapCache(int maxSize) {
super(maxSize);
} public LruBitmapCache(Context ctx) {
this(getCacheSize(ctx));
} @Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight();
} @Override
public Bitmap getBitmap(String url) {
return get(url);
} @Override
public void putBitmap(String url, Bitmap bitmap) {
put(url, bitmap);
} // Returns a cache size equal to approximately three screens worth of images.
public static int getCacheSize(Context ctx) {
final DisplayMetrics displayMetrics = ctx.getResources().
getDisplayMetrics();
final int screenWidth = displayMetrics.widthPixels;
final int screenHeight = displayMetrics.heightPixels;
// 4 bytes per pixel
final int screenBytes = screenWidth * screenHeight * 4; return screenBytes * 3;
}
}

下面演示了如何实例化一个ImageLoader和使用缓存：

RequestQueue mRequestQueue; // assume this exists.
ImageLoader mImageLoader = new ImageLoader(mRequestQueue, new LruBitmapCache(
LruBitmapCache.getCacheSize()));

请求JSON (Request JSON)

Volley 为JSON请求提供了下面的类：

• JsonArrayRequest — 通过一个指定的URL，发送请求到获得一个JSONArray (JSON数组)响应体。
• JsonObjectRequest — 通过一个指定的URL，发送请求到获得一个 JSONObject (JSON对象)响应体,它允许一个可选的JSONObject对象作为参数通过作为请求体的一部分被传送。

这些类都是基于一般基础类JsonRequest的。你可以使用他们就像其他类型的请求一样，比如，下面的示例演示了提取一个JSON feed和以文本的形式在UI显示它。

Both classes are based on the common base class JsonRequest. You use them following the same basic pattern you use for other types of requests. For example, this snippet fetches a JSON feed提要 and displays it as text in the UI:

TextView mTxtDisplay;
ImageView mImageView;
mTxtDisplay = (TextView) findViewById(R.id.txtDisplay);
String url = "http://my-json-feed";JsonObjectRequest jsObjRequest = new JsonObjectRequest
(Request.Method.GET, url, null, new Response.Listener() { @Override
public void onResponse(JSONObject response) {
mTxtDisplay.setText("Response: " + response.toString());
}
}, new Response.ErrorListener() { @Override
public void onErrorResponse(VolleyError error) {
// TODO Auto-generated method stub }
});// Access the RequestQueue through your singleton class.
MySingleton.getInstance(this).addToRequestQueue(jsObjRequest);

要获得一个基于Gson的实习自定义JSON请求的示例，请阅读下一课, Implementing a Custom Request.

实现一个自定义请求（Implementing a Custom Request）

这节课描述了如何实现你的自定义请求类型，这些类型是没有被包含在 Volley支持的 out-of-the-box 类型的。

写一个自定义请求（Write a Custom Request）

在工具盒中，有很多请求是可以 准备-即用 的；如果你的响应是一个字符串，图片，或者JSON，或许你不再需要去实现一个自定义请求。

在那些你想要去实现自定义请求的情形中，这些时你需要做的：

• 继承 Request<T> 类, 在这里 <T>表示你的请求期望解析到的类型。如果你的解析后的响应是一个字符串，例如，创建你的自定义请求时要继承Request<String>。详情见更多Volley工具盒中的类  StringRequest 和 ImageRequest 继承自 Request<T>的示例。
• Implement the abstract methods parseNetworkResponse() and deliverResponse(), described in more detail below.

解析网络请求（parseNetworkResponse）

一个响应封装了一个解析后的响应用于传输，为了一个指定的类型（比如字符串，图片，或者JSON）。 下面是一个实现 parseNetworkResponse() 的示例：

@Override
protected Response<T> parseNetworkResponse(
NetworkResponse response) {
try {
String json = new String(response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(gson.fromJson(json, clazz),
HttpHeaderParser.parseCacheHeaders(response));
}
// handle errors
...
}

注意下面:

• parseNetworkResponse() 有一个参数 NetworkResponse, 它包含了 装载了 字节数组 byte[] 的响应，HTTP状态码，和响应头。
• 你的实现必须返回一个 Response<T>, 它包含了你的类型化的（强类型的）响应对象和缓存元数据，或者在解析失败时的错误

如果你的协议中包含了非标准的语义，你可以构造一个你自己的 Cache.Entry，但是大多数的请求像下面这样是好用的：

return Response.success(myDecodedObject,
HttpHeaderParser.parseCacheHeaders(response));

Volley 在一个工作现场中调用 parseNetworkResponse(). 这确保了昂贵的解析操作比如对一个JPEG图像进行解码到一个位图对象中，不会阻塞UI线程。

传输响应 （deliverResponse）

Volley 使用你的 parseNetworkResponse()中返回的对象到主线程进行回调。许多请求在这里调用回调接口，例如： 

protected void deliverResponse(T response) {
listener.onResponse(response);

GSON请求示例：GsonRequest（Example: GsonRequest）

Gson 是一个类库，使用反射的方法作用于互相转换Java对象和JSON 。你可以定义一个和那些JSON的键名称具有相同名称的字段的Java对象。将类的对象传递给GSON，而GSON将会为你自动填充这些字段的值。下面是一个使用GSON解析的Volley请求的完整的实现：

public class GsonRequest<T> extends Request<T> {
private final Gson gson = new Gson();
private final Class<T> clazz;
private final Map<String, String> headers;
private final Listener<T> listener; /**
* Make a GET request and return a parsed object from JSON.
*
* @param url URL of the request to make
* @param clazz Relevant class object, for Gson's reflection
* @param headers Map of request headers
*/
public GsonRequest(String url, Class<T> clazz, Map<String, String> headers,
Listener<T> listener, ErrorListener errorListener) {
super(Method.GET, url, errorListener);
this.clazz = clazz;
this.headers = headers;
this.listener = listener;
} @Override
public Map<String, String> getHeaders() throws AuthFailureError {
return headers != null ? headers : super.getHeaders();
} @Override
protected void deliverResponse(T response) {
listener.onResponse(response);
} @Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
try {
String json = new String(
response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(
gson.fromJson(json, clazz),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (JsonSyntaxException e) {
return Response.error(new ParseError(e));
}
}
}

Volley 提供了 准备-即用 的 JsonArrayRequest 和 JsonArrayObject 类， 如果你更加喜欢这种方式. 请阅读 Using Standard Request Types 获得更多信息。