Volley扩展:图片加载，同步方式请求数据

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被唤醒。