編輯：關於Android編程
在Android應用開發：網絡工具——Volley（一）中結合Cloudant服務介紹了Volley的一般用法，其中包含了兩種請求類型StringRequest和JsonObjectRequest。一般的請求任務相信都可以通過他們完成了，不過在千變萬化的網絡編程中，我們還是希望能夠對請求類型、過程等步驟進行完全的把控，本文就從Volley源碼角度來分析一下，一個網絡請求在Volley中是如何運作的，也可以看作網絡請求在Volley中的生命周期。
在使用Volley前，必須有一個網絡請求隊列來承載請求，所以先分析一下這個請求隊列是如何申請，如果運作的。在Volley.java中：
/**
* 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);
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}
if (stack == null) {
if (Build.VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork(stack);
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.
*
* @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);
}
通常使用的是第二個接口，也就是只有一個參數的newRequestQueue(Context context)，使stack默認為null。可以看到我們得到的RequestQueue是通過RequestQueue申請，然後又調用了其start方法，最後返回給我們的。接下來看一下RequestQueue的構造方法：
/**
* 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
* @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.
*
* @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);
}RequestQueue有三種構造方法，通過newRequestQueue(Context context)調用的是最後一種。創建了一個工作池，默認承載網絡線程數量為4個。而後兩種構造方法都會調用到第一個，進行了一些局部變量的賦值，並沒有什麼需要多說的，接下來看start()方法：
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();
}
}
首先進行了stop操作，將所有的執行者全部退出，從而確保當前沒有任何正在工作的執行者。然後主要的工作就是開啟一個CacheDispatcher和符合線程池數量的NetworkDispatcher。首先分析CacheDispatcher。
CacheDispatcher為緩存隊列處理器，創建伊始就被責令開始工作start()，因為CacheDispatcher繼承於Thread類，所以需要看一下它所復寫的run方法：
@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.
final Request request = mCacheQueue.take(); //在緩存序列中獲取請求，阻塞操作
request.addMarker("cache-queue-take");
// If the request has been canceled, don't bother dispatching it.
if (request.isCanceled()) { //若該請求已經被取消了，則直接跳過
request.finish("cache-discard-canceled");
continue;
}
// Attempt to retrieve this item from cache.
Cache.Entry entry = mCache.get(request.getCacheKey()); //嘗試在緩存中查找是否有緩存數據
if (entry == null) {
request.addMarker("cache-miss"); //若沒有則緩存丟失，證明這個請求並沒有獲得實施過，扔進網絡請求隊列中
// Cache miss; send off to the network dispatcher.
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)); //請求有緩存數據且沒有過期，那麼可以進行解析，交給請求的parseNetworkReponse方法進行解析，這個方法我們可以在自定義個Request中進行復寫自定義
request.addMarker("cache-hit-parsed");
if (!entry.refreshNeeded()) { //如果請求有效且並不需要刷新，則丟進Delivery中處理，最終會觸發如StringRequest這樣的請求子類的onResponse或onErrorResponse
// Completely unexpired cache hit. Just deliver the 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.
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;
}
}
}
CacheDispatcher做了很多事情，之後再來慢慢的消化他們。現在先看一下我們的請求通過add之後到了哪裡去。查看RequestQueue.java的add方法：
/**
* Adds a Request to the dispatch queue.
* @param request The request to service
* @return The passed-in request
*/
public Request add(Request 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); //加入到當前的隊列中，是一個HashSet
}
// 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.若這個請求不需要被緩存，需要直接做網絡請求，那麼就直接加到網絡請求隊列中
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there's already a request with the same cache key in flight.
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey(); // Volley中使用請求的URL作為存儲的key
if (mWaitingRequests.containsKey(cacheKey)) { //若等待的請求中有與所請求的URL相同的請求，則需要做層級處理
// There is already a request in flight. Queue up.
Queue> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests); //若與已有的請求URL相同，則創建一個層級列表保存他們，然後再放入等待請求列表中
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); //若是一個全新的請求，則直接放入等待隊列中，注意數據為null，只有多個url產生層級關系了才有數據
mCacheQueue.add(request); //放入緩存隊列中，緩存隊列會對請求做處理
}
return request;
}
} 這裡的mCacheQueue就是放入CacheDispatcher的那個阻塞隊列，所以在add中添加到mCacheQueue後，因為CacheDispatcher已經運行起來了，所以CacheDispatcher會對剛剛加入的網絡請求做處理。分析到這裡，可以進行一下階段性的梳理：
1. 我們的請求在加入到RequestQueue後，首先會加入到其實體類的mCurrentRequests列表中做本地管理
2. 如果之前已經存在了和本次請求相同URL的請求，那麼會將層級關系保存在mWaitingRequests中，若沒有則層級關系為null，同樣也會保存在mWaitingRequests中
3. 對於沒有層級關系（新的URL）的網絡請求會直接放入mCacheQueue中讓CacheDispatcher對其進行處理
分析到這裡發現對於同一個URL的請求處理比較特殊，當第一次做某個網絡請求A時候，A會直接放入緩存隊列中由CacheDispatcher進行處理。下一次進行同一個URL的請求B時，若此時A還存在於mWaitingRequests隊列中則B的請求被雪藏，不放入mCacheQueue緩存隊列進行處理，只是等待。那麼等待到什麼時候呢？不難猜想到是需要等待A的請求完畢後才可以進行B的請求。歸結到底就是需要知道mWaitingRequest是如何運作的？什麼時候存儲在其中的層級結構才會被拿出來進行請求。暫時記下這個問題，現在回頭再去繼續分析CacheDispatcher。CacheDispatcher對請求的處理可以歸結為以下幾種情況：
1. 對於取消的請求，直接表示為完成並跳過；
2. 對於尚未有應答數據的、數據過期、有明顯標示需要刷新的請求直接丟入mNetworkQueue，mNetworkQueue同mCacheQueue一樣，是一個阻塞隊列；
3. 對於有應答數據且數據尚未過期的請求會出發Request的parseNetworkResponse方法進行數據解析，這個方法可以通過繼承Request類進行復寫（定制）；
4. 對於有效應答（無論是否需要更新）都會用mDelivery進行應答，需要刷新的請求則會再次放入到mNetworkQueue中去。
對於（1）暫不做分析，後邊會遇到。下邊分析一下mNetworkQueue的運作原理，mNetworkQueue是在CacheDispatcher構造時傳入的參數，通過RequestQueue的start()方法不難分析出相對應的處理器為NetworkDispatcher。
在RequestQueue的start()方法中，NetworkDispatcher存在多個，其數量等於RequestQueue構造時候傳入的網絡處理線程數量相等，默認為4個。
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();
}
}
