[关闭]
@flyouting 2014-07-12T14:51:33.000000Z 字数 6168 阅读 3500

Volley源码学习笔记三

Android volley

图片获取

在volley中有个ImageLoader用于专门加载图片，看一下其中的重要对象：

  1.     /** 处理ImageRequest的请求队列. */
  2.     private final RequestQueue mRequestQueue;
  4.     /** 第一级缓冲区，在进入volley前首先会这里查看有没有缓存 */
  5.     private final ImageCache mCache;
  7.     /**
  8.      * 一个keys -> BatchedImageRequest的HashMap，
  9.      * 用来跟踪动态请求,这样我们可以合并多个请求相同的URL到一个网络请求。
  10.      */
  11.     private final HashMap<String, BatchedImageRequest> mInFlightRequests =
  12.             new HashMap<String, BatchedImageRequest>();
  14.     /** 一个保存当前需要等待响应HashMap */
  15.     private final HashMap<String, BatchedImageRequest> mBatchedResponses =
  16.             new HashMap<String, BatchedImageRequest>();

ImageLoader的构造方法只需要传入一个请求队列对象，和一个缓冲区对象。

  1.  public ImageLoader(RequestQueue queue, ImageCache imageCache) {
  2.         mRequestQueue = queue;
  3.         mCache = imageCache;
  4.     }

这个一级缓冲区对象我们可以自行扩展，只需要实现ImageCache接口即可。常用的就是LRUCahce。

在看ImageLoader中执行网络请求获得图片的代码前，需要先了解ImageContainer和BatchedImageRequest这两个类是什么概念，因为这关系到重复行url请求的合并。先看下ImageContainer：

  1. public class ImageContainer {
  3.         private Bitmap mBitmap;
  4.         private final ImageListener mListener;
  5.         private final String mCacheKey;
  6.         private final String mRequestUrl;
  8.         public ImageContainer(Bitmap bitmap, String requestUrl,
  9.                 String cacheKey, ImageListener listener) {
  10.             mBitmap = bitmap;
  11.             mRequestUrl = requestUrl;
  12.             mCacheKey = cacheKey;
  13.             mListener = listener;
  14.         }
  16.         public void cancelRequest() {
  17.             if (mListener == null) {
  18.                 return;
  19.             }
  21.             BatchedImageRequest request = mInFlightRequests.get(mCacheKey);
  22.             if (request != null) {
  23.                 boolean canceled = request.removeContainerAndCancelIfNecessary(this);
  24.                 if (canceled) {
  25.                     mInFlightRequests.remove(mCacheKey);
  26.                 }
  27.             } else {
  28.                 // check to see if it is already batched for delivery.
  29.                 request = mBatchedResponses.get(mCacheKey);
  30.                 if (request != null) {
  31.                     request.removeContainerAndCancelIfNecessary(this);
  32.                     if (request.mContainers.size() == 0) {
  33.                         mBatchedResponses.remove(mCacheKey);
  34.                     }
  35.                 }
  36.             }
  37.         }
  38.     }

这个类其实就是对图片请求相关数据进行了一次封装，包含了图片对象，图片缓存key，图片URL，图片的回调监听器。并包含了一个取消请求的方法。

再来看看BatchedImageRequest，这个其实是图片网络请求的一个封装，跟上个类不同的是，一个是对数据的封装，一个是对请求的封装，上边那个类对应的是一个具体位置的请求，这个类是对应的某一个URL的请求，比如app中有三个位置的imageview请求同一个url的图片，那就会有三个ImageContainer,而只有一个BatchedImageRequest。

  1.  private class BatchedImageRequest {
  2.         /** 被追踪的请求 */
  3.         private final Request<?> mRequest;
  5.         /** 请求返回的图片数据 */
  6.         private Bitmap mResponseBitmap;
  8.         /** 返回出现错误 */
  9.         private VolleyError mError;
  11.         /** 对于同一个url的request的有效的ImageContainers列表 */
  12.         private final LinkedList<ImageContainer> mContainers = new LinkedList<ImageContainer>();
  15.         public BatchedImageRequest(Request<?> request, ImageContainer container) {
  16.             mRequest = request;
  17.             mContainers.add(container);
  18.         }
  20.         /**
  21.          * 如果出现其他同地址的请求，把ImageContainer添加进来
  22.          */
  23.         public void addContainer(ImageContainer container) {
  24.             mContainers.add(container);
  25.         }
  27.         /**
  28.          * 某个ImageContainer被取消，即某个位置的图片请求取消，从当前列表中移除，如果是最后一个，代表这个请求不需要了，会取消整个请求
  29.          */
  30.         public boolean removeContainerAndCancelIfNecessary(ImageContainer container) {
  31.             mContainers.remove(container);
  32.             if (mContainers.size() == 0) {
  33.                 mRequest.cancel();
  34.                 return true;
  35.             }
  36.             return false;
  37.         }
  38.     }

简单说就是 BatchedImageRequest对象是请求某一个url的图片数据的执行者，如果好几个ImageView都需要加载同一个url的图片，那就会生成若干个ImageContainer加到BatchedImageRequest里来。代表这些都是同一请求。

现在可以看图片获取部分的代码了：

  1.  public ImageContainer get(String requestUrl, ImageListener imageListener,
  2.             int maxWidth, int maxHeight) {
  3.         // only fulfill requests that were initiated from the main thread.
  4.         throwIfNotOnMainThread();
  6.         final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);
  8.         // Try to look up the request in the cache of remote images.
  9.         Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
  10.         if (cachedBitmap != null) {
  11.             // Return the cached bitmap.
  12.             ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
  13.             imageListener.onResponse(container, true);
  14.             return container;
  15.         }
  17.         // The bitmap did not exist in the cache, fetch it!
  18.         ImageContainer imageContainer =
  19.                 new ImageContainer(null, requestUrl, cacheKey, imageListener);
  21.         // Update the caller to let them know that they should use the default bitmap.
  22.         imageListener.onResponse(imageContainer, true);
  24.         // Check to see if a request is already in-flight.
  25.         BatchedImageRequest request = mInFlightRequests.get(cacheKey);
  26.         if (request != null) {
  27.             // If it is, add this request to the list of listeners.
  28.             request.addContainer(imageContainer);
  29.             return imageContainer;
  30.         }
  32.         // The request is not already in flight. Send the new request to the network and
  33.         // track it.
  34.         Request<?> newRequest =
  35.             new ImageRequest(requestUrl, new Listener<Bitmap>() {
  36.                 @Override
  37.                 public void onResponse(Bitmap response) {
  38.                     onGetImageSuccess(cacheKey, response);
  39.                 }
  40.             }, maxWidth, maxHeight,
  41.             Config.RGB_565, new ErrorListener() {
  42.                 @Override
  43.                 public void onErrorResponse(VolleyError error) {
  44.                     onGetImageError(cacheKey, error);
  45.                 }
  46.             });
  48.         mRequestQueue.add(newRequest);
  49.         mInFlightRequests.put(cacheKey,
  50.                 new BatchedImageRequest(newRequest, imageContainer));
  51.         return imageContainer;
  52.     }

需要传入图片url，回调的监听器，目标图片的宽高，首先是获取cachekey，这个key是由图片url和宽高一起组成的。由这个key从一级缓冲区里查看有无缓存，如果有的话，封装一个默认的ImageContainer返回，没有的话，去正在运行的图片请求集合里去查，当前url是否正在被请求，如果是的话，把当前ImageContainer添加进入Request里的ImageContainer列表。否则的话，生成一个ImageRequest，添加进入队列执行网络请求，并在正在执行的网络集合中mInFlightRequests中添加此请求。

图片获取到之后是怎么操作的呢，在上代码中看到，会执行onGetImageSuccess(cacheKey, response)方法。

  1.  private void onGetImageSuccess(String cacheKey, Bitmap response) {
  2.         // cache the image that was fetched.
  3.         mCache.putBitmap(cacheKey, response);
  5.         // remove the request from the list of in-flight requests.
  6.         BatchedImageRequest request = mInFlightRequests.remove(cacheKey);
  8.         if (request != null) {
  9.             // Update the response bitmap.
  10.             request.mResponseBitmap = response;
  12.             // Send the batched response
  13.             batchResponse(cacheKey, request);
  14.         }

首先是把取得的bitmap放到一级缓冲区里，然后从正在执行的Request列表中移除，并把Request里的mResponseBitmap对象设置好，接着执行batchResponse(cacheKey, request)方法。

  1. private void batchResponse(String cacheKey, BatchedImageRequest request) {
  2.         mBatchedResponses.put(cacheKey, request);
  3.         // If we don't already have a batch delivery runnable in flight, make a new one.
  4.         // Note that this will be used to deliver responses to all callers in mBatchedResponses.
  5.         if (mRunnable == null) {
  6.             mRunnable = new Runnable() {
  7.                 @Override
  8.                 public void run() {
  9.                     for (BatchedImageRequest bir : mBatchedResponses.values()) {
  10.                         for (ImageContainer container : bir.mContainers) {
  11.                             // If one of the callers in the batched request canceled the request
  12.                             // after the response was received but before it was delivered,
  13.                             // skip them.
  14.                             if (container.mListener == null) {
  15.                                 continue;
  16.                             }
  17.                             if (bir.getError() == null) {
  18.                                 container.mBitmap = bir.mResponseBitmap;
  19.                                 container.mListener.onResponse(container, false);
  20.                             } else {
  21.                                 container.mListener.onErrorResponse(bir.getError());
  22.                             }
  23.                         }
  24.                     }
  25.                     mBatchedResponses.clear();
  26.                     mRunnable = null;
  27.                 }
  29.             };
  30.             // Post the runnable.
  31.             mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
  32.         }
  33.     }

首先是把BatchedImageRequest扔到了待处理的BatchedImageRequest的hashmap里，即mBatchedResponses，然后是遍历mBatchedResponses，依次获取其中的BatchedImageRequest对象，然后遍历这个对象中的ImageContainer集合，依次执行ImageContainer里的listener的回调方法。这样在默认的listener中就会设置图片到ImageView上了。

最后附上网上借用的流程图：

此处输入图片的描述

作者： flyouting

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注