建立请求队列（RequestQueue）

编写:kesenhoo - 原文:http://developer.android.com/training/volley/requestqueue.html

前一节课演示了如何使用 Volley.newRequestQueue 这一简便的方法来建立一个RequestQueue，这是利用了 Volley 默认行为的优势。这节课会介绍如何显式地建立一个 RequestQueue，以便满足我们自定义的需求。

这节课同样会介绍一种推荐的实现方式：创建一个单例的 RequestQueue，这使得 RequestQueue 能够持续保持在我们 app 的生命周期中。

建立网络和缓存

一个 RequestQueue 需要两部分来支持它的工作：一部分是网络操作，用来传输请求，另外一个是用来处理缓存操作的 Cache。在 Volley 的工具箱中包含了标准的实现方式：DiskBasedCache 提供了每个文件与对应响应数据一一映射的缓存实现。 BasicNetwork 提供了一个基于 AndroidHttpClient 或者 HttpURLConnection 的网络传输。

BasicNetwork 是 Volley 默认的网络操作实现方式。一个 BasicNetwork 必须使用我们的 app 用于连接网络的 HTTP Client 进行初始化。这个 Client 通常是AndroidHttpClient 或者 HttpURLConnection：

  • 对于 app target API level 低于 API 9（Gingerbread）的使用 AndroidHttpClient。在 Gingerbread 之前，HttpURLConnection 是不可靠的。对于这个的细节，请参考 Android’s HTTP Clients。
  • 对于 API Level 9 以及以上的，使用 HttpURLConnection。

我们可以通过检查系统版本选择合适的 HTTP Client，从而创建一个能够运行在所有 Android 版本上的应用。例如：

  1. HttpStack stack;
  2. ...
  3. // If the device is running a version >= Gingerbread...
  4. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
  5.     // ...use HttpURLConnection for stack.
  6. } else {
  7.     // ...use AndroidHttpClient for stack.
  8. }
  9. Network network = new BasicNetwork(stack);

下面的代码片段演示了如何一步步建立一个 RequestQueue:

  1. RequestQueue mRequestQueue;
  3. // Instantiate the cache
  4. Cache cache = new DiskBasedCache(getCacheDir(), 1024 * 1024); // 1MB cap
  6. // Set up the network to use HttpURLConnection as the HTTP client.
  7. Network network = new BasicNetwork(new HurlStack());
  9. // Instantiate the RequestQueue with the cache and network.
  10. mRequestQueue = new RequestQueue(cache, network);
  12. // Start the queue
  13. mRequestQueue.start();
  15. String url ="http://www.myurl.com";
  17. // Formulate the request and handle the response.
  18. StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
  19.         new Response.Listener<String>() {
  20.     @Override
  21.     public void onResponse(String response) {
  22.         // Do something with the response
  23.     }
  24. },
  25.     new Response.ErrorListener() {
  26.         @Override
  27.         public void onErrorResponse(VolleyError error) {
  28.             // Handle error
  29.     }
  30. });
  32. // Add the request to the RequestQueue.
  33. mRequestQueue.add(stringRequest);
  34. ...

如果我们仅仅是想做一个单次的请求并且不想要线程池一直保留，我们可以通过使用在前面一课：发送一个简单的请求（Sending a Simple Request）文章中提到的 Volley.newRequestQueue() 方法，在任何需要的时刻创建 RequestQueue，然后在我们的响应回调里面执行 stop() 方法来停止操作。但是更通常的做法是创建一个 RequestQueue 并设置为一个单例。下面部分将演示这种做法。

使用单例模式

如果我们的应用需要持续地使用网络，更加高效的方式应该是建立一个 RequestQueue 的单例，这样它能够持续保持在整个 app 的生命周期中。我们可以通过多种方式来实现这个单例。推荐的方式是实现一个单例类，里面封装了 RequestQueue 对象与其它的 Volley 功能。另外一个方法是继承 Application 类，并在 Application.OnCreate() 方法里面建立 RequestQueue。但是我们并不推荐这个方法，因为一个 static 的单例能够以一种更加模块化的方式提供同样的功能。

一个关键的概念是 RequestQueue 必须使用 Application context 来实例化，而不是 Activity context。这确保了 RequestQueue 在我们 app 的生命周期中一直存活，而不会因为 activity 的重新创建而被重新创建(例如，当用户旋转设备时)。

下面是一个单例类，提供了 RequestQueue 与 ImageLoader 功能：

  1. public class MySingleton {
  2.     private static MySingleton mInstance;
  3.     private RequestQueue mRequestQueue;
  4.     private ImageLoader mImageLoader;
  5.     private static Context mCtx;
  7.     private MySingleton(Context context) {
  8.         mCtx = context;
  9.         mRequestQueue = getRequestQueue();
  11.         mImageLoader = new ImageLoader(mRequestQueue,
  12.                 new ImageLoader.ImageCache() {
  13.             private final LruCache<String, Bitmap>
  14.                     cache = new LruCache<String, Bitmap>(20);
  16.             @Override
  17.             public Bitmap getBitmap(String url) {
  18.                 return cache.get(url);
  19.             }
  21.             @Override
  22.             public void putBitmap(String url, Bitmap bitmap) {
  23.                 cache.put(url, bitmap);
  24.             }
  25.         });
  26.     }
  28.     public static synchronized MySingleton getInstance(Context context) {
  29.         if (mInstance == null) {
  30.             mInstance = new MySingleton(context);
  31.         }
  32.         return mInstance;
  33.     }
  35.     public RequestQueue getRequestQueue() {
  36.         if (mRequestQueue == null) {
  37.             // getApplicationContext() is key, it keeps you from leaking the
  38.             // Activity or BroadcastReceiver if someone passes one in.
  39.             mRequestQueue = Volley.newRequestQueue(mCtx.getApplicationContext());
  40.         }
  41.         return mRequestQueue;
  42.     }
  44.     public <T> void addToRequestQueue(Request<T> req) {
  45.         getRequestQueue().add(req);
  46.     }
  48.     public ImageLoader getImageLoader() {
  49.         return mImageLoader;
  50.     }
  51. }

下面演示了利用单例类来执行 RequestQueue 的操作：

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