一、初始化请求队列并运行
我们用Volley时，最先开始的就是初始化请求队列，一种常见的写法如下：
public class MyApplication extends Application {
public static RequestQueue requestQueue;
@Override
public void onCreate() {
super.onCreate();
// 不必为每一次HTTP请求都创建一个RequestQueue对象，推荐在application中初始化
requestQueue = Volley.newRequestQueue(this);
}
}
我们来看看这个newRequestQueue中到底做了什么。
这个流程图分析了Volley的源码，我的建议是先自己耐心的从编译器中看看代码，慢慢通过F3跳转，然后在看文章的解释会比较好，在博客中贴代码感觉不是很适合阅读。我为了方便大家阅读，在源码中加上了注释，看完这段代码再看上面的流程图就很清晰了。
左边部分：
package com.android.volley.toolbox;public class Volley {
/** Default on-disk cache directory. */
private static final String DEFAULT_CACHE_DIR = "volley";
/**
* Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
*
* @param context A {@link Context} to use for creating the cache dir.
* @param stack An {@link HttpStack} to use for the network, or null for default.
* @return A started {@link RequestQueue} instance.
*/
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
// 通过应用程序的包名和版本信息等来完善userAgent字符串
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}
// 如果stack为空，就开始建立一个默认的HttpStack对象
if (stack == null) {
if (Build.VERSION.SDK_INT >= 9) {
// 如果大于9，那么就建立一个HurlStack，其内部用了HttpURLConnection
stack = new HurlStack();
} else {
// 如果在api9之前，HttpUrlConnection是不可靠的，这里用了HttpClient
// 如果你的目标系统是API9之后的，你完全可以删除一些代码来进软件瘦身
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
// 通过stack来建立一个NetWork对象，Network执行网络请求
Network network = new BasicNetwork(stack);
// RequestQueue是分发请求队列的调度员，
// 这里传入了一个Cache对象，用来做磁盘缓存，如果你不用可以进行替换
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start(); // 开始请求队列
return queue;
}
/**
* Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
* 我们之前就是用这个方法进行初始化requestQueue的，这掉用了上面的初始化方法，
* 在stack对象的位置传入了null，表示由代码自动产生一个合适的stack对象
*
* @param context A {@link Context} to use for creating the cache dir.
* @return A started {@link RequestQueue} instance.
*/
public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, null);
}
}
说明：在Gingerbread以及以后的版本中，HttpURLConnection是最好的选择，它简单的api以及轻量级非常适合Android。压缩和缓存机制降低了网路使用，提高了速度、节省了电量。新的应用应该选择使用HttpURLConnection，我们也将做持续的改进。
现在我们知道了，这段代码最终生成了一个RequestQueue，说明它才是重点啊，下面我们就来分析下上图右边部分的流程。
右边部分：
/**
* Creates the worker pool. Processing will not begin until {@link #start()} is called.
* 真正的初始化方法，初始化了network，dispatchers，delivery，cache对象，这里的cache是磁盘缓存的对象
* @param cache A Cache to use for persisting responses to disk
* @param network A Network interface for performing HTTP requests
* @param threadPoolSize Number of network dispatcher threads to create
* @param delivery A ResponseDelivery interface for posting responses and errors
*/
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
} /**
* Creates the worker pool. Processing will not begin until {@link #start()} is called.
*
* @param cache A Cache to use for persisting responses to disk
* @param network A Network interface for performing HTTP requests
* @param threadPoolSize Number of network dispatcher threads to create
*/
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
} /**
* Creates the worker pool. Processing will not begin until {@link #start()} is called.
* Volley类中调用的构造函数，传入了默认的网络线程数，DEFAULT_NETWORK_THREAD_POOL_SIZE = 4（默认是4个线程）
* @param cache A Cache to use for persisting responses to disk
* @param network A Network interface for performing HTTP requests
*/
public RequestQueue(Cache cache, Network network) {
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
} /**
* Starts the dispatchers in this queue.
* 初始化完毕后，会马上调用start()方法
*/
public void start() {
// 先确保当前正在运行的发送对象（Dispatcher）被停止
// 建立一个cahce dispatch对象，并且开启它
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start(); // Create network dispatchers (and corresponding threads) up to the pool size.
// 建立多个访问网络的线程对象，并且运行它们
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
现在我们就知道Volley类中最后的这两行到底做了什么事情了
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
现在我们就能理解上面流程图所示的东西了。
二、添加到Request
我们建立好各种Request对象后，最终都会把它add到RequestQueue中，然后它就能自动进行网络处理了。这里的重点就是RequestQueue的add()方法，所以我们就来看看这是怎样的一个过程。
- mWaitingRequests等待队列，当之前已经存在了与本次请求相同的请求时，会把相同的请求放在队列中，以URL为关键字（key）
- mCurrentRequests存放所有请求，包括已经运行的和正在等待的请求（Request）。
- mCacheQueue表示目前缓存的请求队列，这个队列会被传入到CacheDispatcher做判断。
- mNetworkQueue表示请求网络连接的队列，里面的请求都会向服务器进行请求（这才是唯一和服务器打交道的队列）。
- NetworkDispatcher、CacheDispatcher，阻塞式线程，不断循环处理Request。
- ResonseDelivery(mDelivery)请求结果分发器，会把响应得到的结果发送到主线程的回调方法中，最终传递给监听器。
关键代码就是这个add()方法，其余的方法很简单，就不做说明了。
/**
* Adds a Request to the dispatch queue.
* @param request The request to service
* @return The passed-in request
*/
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对象先给自己内部的mRequestQueue对象进行初始化，存入当前的队列对象
request.setRequestQueue(this);
synchronized (mCurrentRequests) {
// mCurrentRequests会存放所有的请求，无论是不是重复的请求都会被放在这里面，所以一上来就add进来
mCurrentRequests.add(request);
} // Process requests in the order they are added.
// 设置request自身的序列数
request.setSequence(getSequenceNumber());
// 设置request当前的真正进行的事件，现在是被添加到队列中了，所以做了如下标记
request.addMarker("add-to-queue"); // If the request is uncacheable, skip the cache queue and go straight to the network.
// 判断是否允许缓存，这里是磁盘的缓存，
// 如果不允许缓存，直接把request添加到networkQueue中，然后去请求网络
if (!request.shouldCache()) {
mNetworkQueue.add(request); // 添加到mNetworkQueue中，才能进行真正的网络交互
return request; // 如果不允许缓存，添加到networkQueue中后直接返回
} // Insert request into stage if there's already a request with the same cache key in flight.
// 看看现在有没有缓存的数据，这里加了个同步锁
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
// 判断等待队列中是否已经有这个request，如果有了就需要过滤重复请求
if (mWaitingRequests.containsKey(cacheKey)) {
// There is already a request in flight. Queue up.
// 现在等待队列中已经有相同的request对象了，直接等待之前的request执行请求完毕，
// 然后把结果放入这个request中，这样就过滤了重复的请求了
// 现在知道了之前已经有一个相同的请求，就初始化一个stagedRequests（请求队列）
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<Request<?>>();
}
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.
// 在等待队列中添加以cacheKey作为关键字的一组数据，然后放入缓存队列
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
最关键的就是这个add()方法，其余的方法很简单，就不做说明了。
三、缓存队列处理
第一部分讲了RequestQueue初始化后，立即执行了其内部的start()方法
/**
* Starts the dispatchers in this queue.
*/
public void start() {
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start(); // Create network dispatchers (and corresponding threads) up to the pool size.
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
这个方法中首先start了CacheDispatcher，它接收了mCacheQueue, mNetworkQueue, mCache, mDelivery这些参数，它到底是什么东西呢？其实啊，它就是一个线程，继承自Thread，那个start()方法就没啥奇特的了，就是Thread的start()方法。重要的东西就是线程体了，来看看是什么流程。
@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // Make a blocking call to initialize the cache.
// 初始化缓存区
mCache.initialize(); while (true) {
try {
// Get a request from the cache triage queue, blocking until
// at least one is available.
// 从cache队列中取出一个request对象，执行阻塞
final Request<?> request = mCacheQueue.take();
request.addMarker("cache-queue-take"); // 设置当前事件名称 // If the request has been canceled, don't bother dispatching it.
// 如果这个request已经被取消了，就直接finish掉，再去cache队列中取一个新的
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
} // Attempt to retrieve this item from cache.
// 根据缓存的key得到一个entry（响应结果）对象
Cache.Entry entry = mCache.get(request.getCacheKey());
// 判断是否存在
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
// 发现丢失了，放入networkQueue重新请求服务器
mNetworkQueue.put(request);
continue;
} // If it is completely expired（过期，期满）, just send it to the network.
// 如果它已经完全过期了，也让它重新访问网络
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
} // We have a cache hit; parse its data for delivery back to the request.
// 命中到一个缓存
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed"); // 判断是否需要刷新
if (!entry.refreshNeeded()) {
// Completely unexpired cache hit. Just deliver the response.
// 如果根本没有过期，就发送到response中
mDelivery.postResponse(request, response);
} else {
// Soft-expired cache hit. We can deliver the cached response,
// but we need to also send the request to the network for
// refreshing.
// 如果需要重新刷新，那么就发送给network进行刷新
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry); // Mark the response as intermediate.
response.intermediate = true; // Post the intermediate response back to the user and have
// the delivery then forward the request along to the network.
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
} } catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
}
}
四、网络请求处理
讲解完RequestQueue中的cacheDispatcher的start()后，我们来看看NetworkDispatcher.
/**
* Starts the dispatchers in this queue.
*/
public void start() {
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start(); // Create network dispatchers (and corresponding threads) up to the pool size.
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
在RequestQueuestart()时，直接循环创建了多个NetworkDispatcher对象，并且让其star().通过上面的分析，我们有理由猜测NetworkDispatcher也是一个Thread对象，那么就来看看它的流程。
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
long startTimeMs = SystemClock.elapsedRealtime();
Request<?> request;
try {
// Take a request from the queue.
// 从queue中取出一个request对象
request = mQueue.take();
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
} try {
// 记录当前事务信息
request.addMarker("network-queue-take"); // If the request was cancelled already, do not perform the
// network request.
// 如果这个request已经被取消了，那么就不再执行网络请求
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
} addTrafficStatsTag(request); // Perform the network request.
// 完成网络请求
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete"); // 记录当前事务信息 // If the server returned 304 AND we delivered a response already,
// 如果返回304，并且我们已经分发了响应的结果
// we're done -- don't deliver a second identical response.
// 验证当前是否有更新请求（304是标志）
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
} // Parse the response here on the worker thread.
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete"); // 如果可用，就放入缓存中，这里要检查是否允许缓存（磁盘缓存）
// Write to cache if applicable.
// TODO: Only update cache metadata instead of entire record for 304s.
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
} // Post the response back.
request.markDelivered();
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
}
}
阅读完源码后发现：networkDispatcher做的是一个网络处理，而mCacheDispatcher做的是缓存处理。
networkDispatcher判断当前返回的结果是否需要更新，是否需要再次请求网络；mCacheDispatcher做的是判断当前是否有缓存，缓存的信息是否可用，不可用时就去请求网络。二者的行为类似，整体构成了RequestQueue的start()方法。我们可以理解为RequestQueue主要做的就是开启了多个不同功能的线程，并进行管理。
五、数据分发器
很抱歉的是，我又把上面的那个start()代码拿过来了，这回讲解的是mDelivery对象。这个对象被当作参数放入了CacheDispatcher、NetworkDispatcher中，它做的就是数据的分发工作。
/**
* Starts the dispatchers in this queue.
*/
public void start() {
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start(); // Create network dispatchers (and corresponding threads) up to the pool size.
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
ResponseDelivery是一个接口，ExecutorDelivery实现了它。这个接口的代码如下：
package com.android.volley;
public interface ResponseDelivery {
/**
* Parses a response from the network or cache and delivers it.
*/
public void postResponse(Request<?> request, Response<?> response);
/**
* Parses a response from the network or cache and delivers it. The provided
* Runnable will be executed after delivery.
*/
public void postResponse(Request<?> request, Response<?> response, Runnable runnable);
/**
* Posts an error for the given request.
*/
public void postError(Request<?> request, VolleyError error);
}
内部有重要的分发方法，发送正确结果信息，发送响应失败的信息。
/**
* A Runnable used for delivering network responses to a listener on the
* main thread.
* 用于分发网络的响应结果到主线程的一个runnable
*/
@SuppressWarnings("rawtypes")
private class ResponseDeliveryRunnable implements Runnable {
private final Request mRequest;
private final Response mResponse;
private final Runnable mRunnable; public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
mRequest = request;
mResponse = response;
mRunnable = runnable;
} @SuppressWarnings("unchecked")
@Override
public void run() {
// If this request has canceled, finish it and don't deliver.
// 看看是否已经被取消了，如果被取消了，结束它，不做分发处理
if (mRequest.isCanceled()) {
mRequest.finish("canceled-at-delivery");
return;
} // Deliver a normal response or error, depending.
// 分发一个普通的响应结果，可能是出错响应
if (mResponse.isSuccess()) {
mRequest.deliverResponse(mResponse.result);
} else {
mRequest.deliverError(mResponse.error);
} // If this is an intermediate response, add a marker, otherwise we're done
// and the request can be finished.
if (mResponse.intermediate) {
mRequest.addMarker("intermediate-response");
} else {
mRequest.finish("done");
} // If we have been provided a post-delivery runnable, run it.
if (mRunnable != null) {
mRunnable.run();
}
}
}
六、总结
整体流程总结：
其中蓝色部分代表主线程，绿色部分代表缓存线程，橙色部分代表网络线程。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。
详细总结：
1. 当一个RequestQueue被成功申请后会开启一个CacheDispatcher（缓存调度器）和4个（默认）NetworkDispatcher（网络请求调度器）；
2. CacheDispatcher缓存调度器最为第一层缓冲，开始工作后阻塞的从缓存序列mCacheQueue中取得请求：
a. 对于已经取消了的请求，直接标记为跳过并结束这个请求
b. 全新或过期的请求，直接丢入mNetworkQueue中交由N个NetworkDispatcher进行处理
c. 已获得缓存信息（网络应答）却没有过期的请求，交由Request的parseNetworkResponse进行解析，从而确定此应答是否成功。然后将请求和应答交由Delivery分发者进行处理，如果需要更新缓存那么该请求还会被放入mNetworkQueue中
3. 用户将请求Request add到RequestQueue之后：
a. 对于不需要缓存的请求（需要额外设置，默认是需要缓存）直接丢入mNetworkQueue交由N个NetworkDispatcher处理；
b. 对于需要缓存的，全新的请求加入到mCacheQueue中给CacheDispatcher处理
c. 需要缓存，但是缓存列表中已经存在了相同URL的请求，放在mWaitingQueue中做暂时雪藏，待之前的请求完毕后，再重新添加到mCacheQueue中；
4. 网络请求调度器NetworkDispatcher作为网络请求真实发生的地方，对消息交给BasicNetwork进行处理，同样的，请求和结果都交由Delivery分发者进行处理；
5. Delivery分发者实际上已经是对网络请求处理的最后一层了，在Delivery对请求处理之前，Request已经对网络应答进行过解析，此时应答成功与否已经设定。而后Delivery根据请求所获得的应答情况做不同处理：
a. 若应答成功，则触发deliverResponse方法，最终会触发开发者为Request设定的Listener
b. 若应答失败，则触发deliverError方法，最终会触发开发者为Request设定的ErrorListener
处理完后，一个Request的生命周期就结束了，Delivery会调用Request的finish操作，将其从mRequestQueue中移除，与此同时，如果等待列表中存在相同URL的请求，则会将剩余的层级请求全部丢入mCacheQueue交由CacheDispatcher进行处理。
一个Request的生命周期：
1. 通过add加入mRequestQueue中，等待请求被执行；
2. 请求执行后，调用自身的parseNetworkResponse对网络应答进行处理，并判断这个应答是否成功；
3. 若成功，则最终会触发自身被开发者设定的Listener；若失败，最终会触发自身被开发者设定的ErrorListener。
更多volley的源码分析：
http://blog.csdn.net/guolin_blog/article/details/17656437
http://blog.csdn.net/airk000/article/details/39003587
http://blog.csdn.net/ttdevs/article/details/17764351
流程图来自：
http://www.cnblogs.com/cpacm/p/4211719.html
其他参考文献：
http://blog.csdn.net/t12x3456/article/details/9221611