Volley源码学习笔记_RequestQueue和BasicNetWork

1.开始

Volley也只是听过没用过，新接的项目里面请求用的是Volley，只能赶鸭子上架的看了些简单的使用。现在理解下源码。（ps:这里不涉及有关图片相关的部分pps：理解不对的地方请指出，灰常感谢）

2.Volley的使用

关于Volley的使用，比较简洁的。

//首先创建请求队列
RequestQueue requestQueue = Volley.newRequestQueue(Context);
//创建一个request
Request request=new Request() {...};
//将request添加到请求队列中
requestQueue.add(request);

下面根据上面的三行代码，来一步步的看相关的实现源码。

3.RequestQueue

我们先看 new RequestQueue的代码，它只传入了一个Context

public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, (HttpStack)null);
}

public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
File cacheDir = new File(context.getCacheDir(), "volley");
String userAgent = "volley/0";

try {
String network = context.getPackageName();
PackageInfo queue = context.getPackageManager().getPackageInfo(network, 0);
userAgent = network + "/" + queue.versionCode;
} catch (NameNotFoundException var6) {
;
}

if(stack == null) {
if(VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}

BasicNetwork network1 = new BasicNetwork((HttpStack)stack);
RequestQueue queue1 = new RequestQueue(new DiskBasedCache(cacheDir), network1);
queue1.start();
return queue1;
}

以上代码包含的内容还是很多的。主要是先根据VERSION.SDK_INT

来判断使用什么网络连接请求类。然后实例化一个BasicNetWork来进行网络交互请求。 然后创建一个请求队列，传入一个DiskBasedCache，一个BasicNetwork，最后队列start。下面先看一下RequestQueue的构造函数。

public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {

//下面这5个有的是直接在外面初始化的
this.mSequenceGenerator = new AtomicInteger();
this.mWaitingRequests = new HashMap();
this.mCurrentRequests = new HashSet();
this.mCacheQueue = new PriorityBlockingQueue();
this.mNetworkQueue = new PriorityBlockingQueue();
//这里
this.mCache = cache;
this.mNetwork = network;
this.mDispatchers = new NetworkDispatcher[threadPoolSize];
this.mDelivery = delivery;
}

public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize, new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}

public RequestQueue(Cache cache, Network network) {
this(cache, network, 4);
}

从下往上， this(cache, network, 4);这是的4就是线程数目，记得之前好像还是可以自己输入的现在默认是4个。这里有一个ExecutorDelivery，主要作用就是传递消息（response）,可以看到它的实现要传递一个Handler。这个后期再看。下面看一下RequestQueue的start()。

public void start() {
this.stop();
this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
this.mCacheDispatcher.start();

for(int i = 0; i < this.mDispatchers.length; ++i) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(this.mNetworkQueue, this.mNetwork, this.mCache, this.mDelivery);
this.mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}

}

从上面可以看出，只要new了一个RequestQueue那么就会开启1个缓存线程，4个网络请求

线程。这就意味着一次最多只能并发5个线程，如果缓存线程没有命中，那么最多并发4个网

络请求线程。NetworkDispatcher基本就是从队列中获取请求，然后请求网络数据

（BasicNetWork）同时更新到UI线程。（ExecutorDelivery）。

既然是队列了，那他是如何addRequest的呢？

public <T> Request<T> add(Request<T> request) {
// Tag the request as belonging to this queue and add it to the set of current requests.
request.setRequestQueue(this);
synchronized (mCurrentRequests) {
mCurrentRequests.add(request);
}

// Process requests in the order they are added.
//先记着一个队列序号，先入先出
request.setSequence(getSequenceNumber());
request.addMarker("add-to-queue");

// If the request is uncacheable, skip the cache queue and go straight to the network.
//请求不用缓存就加入到网络请求队列中，但是这个值默认是true
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}

//根据key值判断请求是否已经在重复请求队列，但是会发现最终都是要添加到这个队列里面的
// Insert request into stage if there's already a request with the same cache key in flight.
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
// There is already a request in flight. Queue up.
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
} else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
mWaitingRequests.put(cacheKey, null);
//添加到缓存队列里面去
mCacheQueue.add(request);
}
return request;
}
}

RequestQueue的add方法，从这里我们可以看到四个参数 mWaitingRequests ，mCurrentRequests ，mCacheQueue ，mNetworkQueue。分别是重复请求队列，当前请求或者等待请求集合，缓存队列，网络请求队列，这里重复队列就是一个Map集合，key是cacheKey，就是getUrl。mCacheQueue ,mNetworkQueue是一个优先级队列 。根据优先级来执行，同等优先级是无序的。

当mCacheQueue或者mNetworkQueue利用add方法添加请求之后，在运行的线程就会接收到请求（Cache线程接收到请求，会将相应的请求提那家到mNetworkQueue，这样在请求线程中就可以处理请求队列中的请求），从而去处理相对应的请求，最后将处理的结果由mDelivery来发送到主线程进行更新。

BasicNetWork的具体作用有：

1）对于已经有缓存的请求，添加其头部信息，如下：

private void addCacheHeaders(Map<String, String> headers, Entry entry) {
if(entry != null) {
if(entry.etag != null) {
headers.put("If-None-Match", entry.etag);
}

if(entry.serverDate > 0L) {
Date refTime = new Date(entry.serverDate);
headers.put("If-Modified-Since", DateUtils.formatDate(refTime));
}

}
}

2）调用 HttpStack 对象去网络中获取数据，返回httpResonse 对象。

httpResponse = this.mHttpStack.performRequest(request, e);

3）根据状态编码来返回不同的NetworkResponse对象

如304（未修改）就返回缓存中的数据，如果不是，则根据响应中的数据，重新构造一个NetworkResponse对象。

if(networkResponse1 == 304) {
return new NetworkResponse(304, request.getCacheEntry().data, responseHeaders1, true);
}
...

long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
this.logSlowRequests(requestLifetime, request, responseContents1, statusCode2);
if(networkResponse1 >= 200 && networkResponse1 <= 299) {
return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
}
...
NetworkResponse networkResponse = null;
if(httpResponse == null) {
throw new NoConnectionError(var15);
}

int statusCode1 = httpResponse.getStatusLine().getStatusCode();
VolleyLog.e("Unexpected response code %d for %s", new Object[]{Integer.valueOf(statusCode1), request.getUrl()});
if(responseContents == null) {
throw new NetworkError(networkResponse);
}

networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
if(statusCode1 != 401 && statusCode1 != 403) {
throw new ServerError(networkResponse);
}

4）BasicNetwork实现了重试的机制

如果第一次从网络获取失败，默认会重新再尝试一次，如果失败，则会将Error返回，默认的实现类是DefaultRetryPolicy类。

private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError {
RetryPolicy retryPolicy = request.getRetryPolicy();
int oldTimeout = request.getTimeoutMs();

try {
retryPolicy.retry(exception);
} catch (VolleyError var6) {
request.addMarker(String.format("%s-timeout-giveup [timeout=%s]", new Object[]{logPrefix, Integer.valueOf(oldTimeout)}));
throw var6;
}

request.addMarker(String.format("%s-retry [timeout=%s]", new Object[]{logPrefix, Integer.valueOf(oldTimeout)}));
}

下面看一下3的内容

//具体代码就不贴了
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
....
}

public interface Network {
NetworkResponse performRequest(Request<?> var1) throws VolleyError;
}

BasicNetwork是Network 的实现类。。Network 的方法只有一个performRequest（），参数是Request。用来获取网络请求到的数据，然后在NetworkDispatcher中被解析后通过ExecutorDelivery将请求结果传到UI线程。

这里有一段代码：

byte[] responseContents1;
if(httpResponse.getEntity() != null) {
responseContents1 = this.entityToBytes(httpResponse.getEntity());
} else {
responseContents1 = new byte[0];
}
if(networkResponse1 >= 200 && networkResponse1 <= 299) {
return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
}

这是请求到数据的时候，然后在状态码返回200-299之间的时候创建一个NetworkResponse对象并将其data设置为获取到内容。除了在状态码304的时候，还有一个地方也创建了NetworkResponse对象。这里的responseContents是开始创建的一个空对象。

networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
if(statusCode1 != 401 && statusCode1 != 403) {
throw new ServerError(networkResponse);
}

以上。不对的地方麻烦大家指出，非常感谢。

参考

[1].http://blog.csdn.net/linmiansheng/article/details/22653841

[2].http://blog.csdn.net/mr_liabill/article/details/50241543

[3].http://f303153041.iteye.com/blog/2281350