ImageLoader
考虑到图片加载的特殊性，Volley提供了ImageLoader和NetworkImageView来方便高效地加载图片。图片的数据量相比于文本信息略大，不宜将图片的数据缓存和文件数据缓存放在一块，ImageLoader提供了单独的图片缓存接口，由于真正的请求还是通过将ImageRequest加入RequestQueue处理的，并且ImageRequest是可以被CacheDispatcher缓存的，这样就能出现图片被缓存到RequestQueue里面的缓存，如果我们要使用ImageLoader加载图片的话，我认为应该根据需要将ImageRequest设置为不可缓存。NetworkImageView需要与ImageLoader结合使用，方便在布局文件里面直接加载图片。
ImageLoader和NetworkImageView详细使用参考官方文档。
实例化ImageLoader，将RequestQueue和我们提供的ImageCache与ImageLoader关联。
public ImageLoader(RequestQueue queue, ImageCache imageCache) {
mRequestQueue = queue;
mCache = imageCache;
}
缓存接口比较简单，获取Bitmap，放置Bitmap。
public interface ImageCache {
public Bitmap getBitmap(String url);
public void putBitmap(String url, Bitmap bitmap);
}
处理图片请求，这里的处理和RequestQueue里面较为相似，先从缓存里面获取，获取成功则直接响应。随后判断有没有相同的请求未被响应的，有则放到mInFlightRequest里，待会批量处理，没有则放到RequestQueue处理。
public ImageContainer get(String requestUrl, ImageListener imageListener,
int maxWidth, int maxHeight, ScaleType scaleType) {
// only fulfill requests that were initiated from the main thread.
throwIfNotOnMainThread();
final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight, scaleType);
// Try to look up the request in the cache of remote images.
Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
if (cachedBitmap != null) {
// Return the cached bitmap.
ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
imageListener.onResponse(container, true);
return container;
}
// The bitmap did not exist in the cache, fetch it!
ImageContainer imageContainer =
new ImageContainer(null, requestUrl, cacheKey, imageListener);
// Update the caller to let them know that they should use the default bitmap.
imageListener.onResponse(imageContainer, true);
// Check to see if a request is already in-flight.
BatchedImageRequest request = mInFlightRequests.get(cacheKey);
if (request != null) {
// If it is, add this request to the list of listeners.
request.addContainer(imageContainer);
return imageContainer;
}
// The request is not already in flight. Send the new request to the network and
// track it.
Request<Bitmap> newRequest = makeImageRequest(requestUrl, maxWidth, maxHeight, scaleType,
cacheKey);
mRequestQueue.add(newRequest);
mInFlightRequests.put(cacheKey,
new BatchedImageRequest(newRequest, imageContainer));
return imageContainer;
}
RequestFuture
前面所说的请求都是异步，有时候我们可能需要同步获取我们的网络数据，Volley也提供了同步获取数据的方式，那就是RequestFuture，实现了Future接口，所以可以通过get获取数据。
public class RequestFuture<T> implements Future<T>, Response.Listener<T>,
Response.ErrorListener {
public static <E> RequestFuture<E> newFuture() {
return new RequestFuture<E>();
}
private RequestFuture() {}
public void setRequest(Request<?> request) {
mRequest = request;
}
}
实现了Reponse.Listener,Response.ErrorListener接口，所以将其作为Request请求的参数,用于接受响应的接口。然后将Request与其关联，主要用来实现Future的取消操作。
向Request添加请求之后就可以通过get获取数据了:
@Override
public T get() throws InterruptedException, ExecutionException {
try {
return doGet(null);
} catch (TimeoutException e) {
throw new AssertionError(e);
}
}
@Override
public T get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return doGet(TimeUnit.MILLISECONDS.convert(timeout, unit));
}
private synchronized T doGet(Long timeoutMs)
throws InterruptedException, ExecutionException, TimeoutException {
if (mException != null) {
throw new ExecutionException(mException);
}
if (mResultReceived) {
return mResult;
}
if (timeoutMs == null) {
wait(0);
} else if (timeoutMs > 0) {
wait(timeoutMs);
}
if (mException != null) {
throw new ExecutionException(mException);
}
if (!mResultReceived) {
throw new TimeoutException();
}
return mResult;
}
@Override
public synchronized void onResponse(T response) {
mResultReceived = true;
mResult = response;
notifyAll();
}
@Override
public synchronized void onErrorResponse(VolleyError error) {
mException = error;
notifyAll();
}
这里有一点比较坑，如果我们是在主线程调用的话，如果响应还没来的话我们我们在这里wait，并且没有设置wait的超时时间，那么就真的一直在这里等了，RequestQueue里面的ResponseDelivery默认是将Runnable通过post的方式放到主线程里面执行的，这里就会导致主线程在这里卡在，Looper里面的消息得不到处理。
即使设置了超时时间那么也是得不到结果的，因为还没有来得及等待Looper里面的消息执行就返回了。所以这里有两种处理方法:
1.将RequestFuture放到Work Thread里面使用，不要在UI线程里面使用。
2.将ResponseDelivery的Handler关联Work Thread的Looper。
上面两点主要目的就是让Response.Listener的调用线程和RequestFuture的调用线程不在同一个线程，这样才能是响应结果实现notifyAll，让get中的wait被唤醒。
