Android Volley的優缺點及原始碼分析
為什麼volley不適合post大量資料，以及為什麼不適合上傳下載大量檔案？
因為，volley中為了提高請求處理的速度，採用了ByteArrayPool進行記憶體中的資料儲存的，如果下載大量的資料，這個儲存空間就會溢位，所以不適合大量的資料。但是由於它的這個儲存空間是記憶體中分配的，當儲存的時候會先從ByteArrayPool中取出一塊已經分配的記憶體區域, 不必每次存資料都要進行記憶體分配，而是先查詢緩衝池中有無適合的記憶體區域，如果有，直接拿來用，從而減少記憶體分配的次數，所以他比較適合大量的資料量少的網路資料互動情況。還有一個原因是volley 的執行緒池是基於陣列實現的，即newFixedThreadPool（4）核心執行緒數不超過4個，也不會自動擴充套件，一旦大資料上傳或者下載長時間佔用了執行緒資源，後續所有的請求都會被阻塞。最後，Volley是不適合上次和下載大檔案，但不代表不能處理大檔案。BasicNetwork是volley處理返回response的預設實現，它是把server返回的流全部匯入記憶體，ByteArrayPool只是一個小於4k的記憶體快取池，在BasicNetwork裡實現。上傳和BasicNetwork應該沒有多大關係，volley也是可以上傳大資料的，volley也是可以下載大資料的，只是你不要使用BasicNetwork就行了。
原始碼分析
其實，Volley的官方文件中本身就附有了一張Volley的工作流程圖，如下圖所示。
多數朋友突然看到一張這樣的圖，應該會和我一樣，感覺一頭霧水吧？沒錯，目前我們對Volley背後的工作原理還沒有一個概念性的理解，直接就來看這張圖自然會有些吃力。不過沒關係，下面我們就去分析一下Volley的原始碼，之後再重新來看這張圖就會好理解多了。
說起分析原始碼，那麼應該從哪兒開始看起呢？這就要回顧一下Volley的用法了，使用Volley的第一步，首先要呼叫Volley.newRequestQueue(context)方法來獲取一個RequestQueue物件，程式碼如下所示：
public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, null);
}
這個方法僅僅只有一行程式碼，只是呼叫了newRequestQueue()的方法過載，並給第二個引數傳入null。那我們看下帶有兩個引數的newRequestQueue()方法中的程式碼，如下所示：
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 {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork(stack);
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
return queue;
}
可以看到，這裡在第10行判斷如果stack是等於null的，則去建立一個HttpStack物件，這裡會判斷如果手機系統版本號是大於9的，則建立一個HurlStack的例項，否則就建立一個HttpClientStack的例項。實際上HurlStack的內部就是使用HttpURLConnection進行網路通訊的，而HttpClientStack的內部則是使用HttpClient進行網路通訊的，這裡為什麼這樣選擇呢？可以參考我之前翻譯的一篇文章Android訪問網路，使用HttpURLConnection還是HttpClient？
建立好了HttpStack之後，接下來又建立了一個Network物件，它是用於根據傳入的HttpStack物件來處理網路請求的，緊接著new出一個RequestQueue物件，並呼叫它的start()方法進行啟動，然後將RequestQueue返回，這樣newRequestQueue()的方法就執行結束了。
那麼RequestQueue的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();
}
}
這裡先是建立了一個CacheDispatcher的例項，然後呼叫了它的start()方法，接著在一個for迴圈裡去建立NetworkDispatcher的例項，並分別呼叫它們的start()方法。這裡的CacheDispatcher和NetworkDispatcher都是繼承自Thread的，而預設情況下for迴圈會執行四次，也就是說當呼叫了Volley.newRequestQueue(context)之後，就會有五個執行緒一直在後臺執行，不斷等待網路請求的到來，其中CacheDispatcher是快取執行緒，NetworkDispatcher是網路請求執行緒。
得到了RequestQueue之後，我們只需要構建出相應的Request，然後呼叫RequestQueue的add()方法將Request傳入就可以完成網路請求操作了，那麼不用說，add()方法的內部肯定有著非常複雜的邏輯，我們來一起看一下：
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.
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();
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<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.
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
可以看到，在第11行的時候會判斷當前的請求是否可以快取，如果不能快取則在第12行直接將這條請求加入網路請求佇列，可以快取的話則在第33行將這條請求加入快取佇列。在預設情況下，每條請求都是可以快取的，當然我們也可以呼叫Request的setShouldCache(false)方法來改變這一預設行為。
OK，那麼既然預設每條請求都是可以快取的，自然就被新增到了快取佇列中，於是一直在後臺等待的快取執行緒就要開始執行起來了，我們看下CacheDispatcher中的run()方法，程式碼如下所示：
public class CacheDispatcher extends Thread {
……
@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));
request.addMarker("cache-hit-parsed");
if (!entry.refreshNeeded()) {
// 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;
}
}
}
}
程式碼有點長，我們只挑重點看。首先在11行可以看到一個while(true)迴圈，說明快取執行緒始終是在執行的，接著在第23行會嘗試從快取當中取出響應結果，如何為空的話則把這條請求加入到網路請求佇列中，如果不為空的話再判斷該快取是否已過期，如果已經過期了則同樣把這條請求加入到網路請求佇列中，否則就認為不需要重發網路請求，直接使用快取中的資料即可。之後會在第39行呼叫Request的parseNetworkResponse()方法來對資料進行解析，再往後就是將解析出來的資料進行回撥了，這部分程式碼我們先跳過，因為它的邏輯和NetworkDispatcher後半部分的邏輯是基本相同的，那麼我們等下合併在一起看就好了，先來看一下NetworkDispatcher中是怎麼處理網路請求佇列的，程式碼如下所示：
public class NetworkDispatcher extends Thread {
……
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Request<?> request;
while (true) {
try {
// Take a request from the queue.
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.
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,
// we're done -- don't deliver a second identical response.
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) {
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
}
}
}
}
同樣地，在第7行我們看到了類似的while(true)迴圈，說明網路請求執行緒也是在不斷執行的。在第28行的時候會呼叫Network的performRequest()方法來去傳送網路請求，而Network是一個介面，這裡具體的實現是BasicNetwork，我們來看下它的performRequest()方法，如下所示：
public class BasicNetwork implements Network {
……
@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
long requestStart = SystemClock.elapsedRealtime();
while (true) {
HttpResponse httpResponse = null;
byte[] responseContents = null;
Map<String, String> responseHeaders = new HashMap<String, String>();
try {
// Gather headers.
Map<String, String> headers = new HashMap<String, String>();
addCacheHeaders(headers, request.getCacheEntry());
httpResponse = mHttpStack.performRequest(request, headers);
StatusLine statusLine = httpResponse.getStatusLine();
int statusCode = statusLine.getStatusCode();
responseHeaders = convertHeaders(httpResponse.getAllHeaders());
// Handle cache validation.
if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry() == null ? null : request.getCacheEntry().data,
responseHeaders, true);
}
// Some responses such as 204s do not have content. We must check.
if (httpResponse.getEntity() != null) {
responseContents = entityToBytes(httpResponse.getEntity());
} else {
// Add 0 byte response as a way of honestly representing a
// no-content request.
responseContents = new byte[0];
}
// if the request is slow, log it.
long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
logSlowRequests(requestLifetime, request, responseContents, statusLine);
if (statusCode < 200 || statusCode > 299) {
throw new IOException();
}
return new NetworkResponse(statusCode, responseContents, responseHeaders, false);
} catch (Exception e) {
……
}
}
}
}
這段方法中大多都是一些網路請求細節方面的東西，我們並不需要太多關心，需要注意的是在第14行呼叫了HttpStack的performRequest()方法，這裡的HttpStack就是在一開始呼叫newRequestQueue()方法是建立的例項，預設情況下如果系統版本號大於9就建立的HurlStack物件，否則建立HttpClientStack物件。前面已經說過，這兩個物件的內部實際就是分別使用HttpURLConnection和HttpClient來傳送網路請求的，我們就不再跟進去閱讀了，之後會將伺服器返回的資料組裝成一個NetworkResponse物件進行返回。
在NetworkDispatcher中收到了NetworkResponse這個返回值後又會呼叫Request的parseNetworkResponse()方法來解析NetworkResponse中的資料，以及將資料寫入到快取，這個方法的實現是交給Request的子類來完成的，因為不同種類的Request解析的方式也肯定不同。還記得我們在上一篇文章中學習的自定義Request的方式嗎？其中parseNetworkResponse()這個方法就是必須要重寫的。
在解析完了NetworkResponse中的資料之後，又會呼叫ExecutorDelivery的postResponse()方法來回撥解析出的資料，程式碼如下所示：
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}
其中，在mResponsePoster的execute()方法中傳入了一個ResponseDeliveryRunnable物件，就可以保證該物件中的run()方法就是在主執行緒當中執行的了，我們看下run()方法中的程式碼是什麼樣的：
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();
}
}
}
程式碼雖然不多，但我們並不需要行行閱讀，抓住重點看即可。其中在第22行呼叫了Request的deliverResponse()方法，有沒有感覺很熟悉？沒錯，這個就是我們在自定義Request時需要重寫的另外一個方法，每一條網路請求的響應都是回撥到這個方法中，最後我們再在這個方法中將響應的資料回撥到Response.Listener的onResponse()方法中就可以了。
好了，到這裡我們就把Volley的完整執行流程全部梳理了一遍，你是不是已經感覺已經很清晰了呢？對了，還記得在文章一開始的那張流程圖嗎，剛才還不能理解，現在我們再來重新看下這張圖：
其中藍色部分代表主執行緒，綠色部分代表快取執行緒，橙色部分代表網路執行緒。我們在主執行緒中呼叫RequestQueue的add()方法來新增一條網路請求，這條請求會先被加入到快取佇列當中，如果發現可以找到相應的快取結果就直接讀取快取並解析，然後回撥給主執行緒。如果在快取中沒有找到結果，則將這條請求加入到網路請求佇列中，然後處理髮送HTTP請求，解析響應結果，寫入快取，並回撥主執行緒。
怎麼樣，是不是感覺現在理解這張圖已經變得輕鬆簡單了？好了，到此為止我們就把Volley的用法和原始碼全部學習完了，相信你已經對Volley非常熟悉並可以將它應用到實際專案當中了，那麼Volley完全解析系列的文章到此結束，感謝大家有耐心看到最後。
相關文章
- Android Volley原始碼分析Android原始碼
- Volley 原始碼分析原始碼
- Volley原始碼分析（二）原始碼
- NUMA架構介紹及優缺點分析架構
- Android Volley框架原始碼解析Android框架原始碼
- Architecture(2)Volley原始碼分析原始碼
- 使用protocolbuffers優缺點分析Protocol
- iOS notification的優勢及缺點iOS
- 引數session_cached_cursors的工作原理及優缺點分析Session
- 部分聚類演算法簡介及優缺點分析聚類演算法
- Android原始碼分析–ArrayMap優化Android原始碼優化
- 宏旺半導體分析EEPROM和FLASH的區別及各自的優缺點
- Redis的應用場景及優缺點Redis
- TCP和UDP的優缺點及區別TCPUDP
- Volley 原始碼探索原始碼
- Android 開源專案原始碼解析 -->Volley 原始碼解析(十五)Android原始碼
- 電子採購系統的優缺點分析及選型建議
- 網路分段優缺點及最佳做法
- Volley原始碼分析【面向介面程式設計的典範】原始碼程式設計
- Docker的優缺點Docker
- 遊戲運營的十八種活動及優缺點遊戲
- MySQL的binlog的格式及優缺點介紹MySql
- 遲到的Volley原始碼解析原始碼
- 6種JavaScript繼承方式及優缺點JavaScript繼承
- RabbitMQ優缺點MQ
- 三種雲原生儲存方案優缺點及應用場景分析
- MySQL索引的優缺點MySql索引
- Android Volley 原始碼解析（二），探究快取機制Android原始碼快取
- 自學IT和接受IT培訓兩者的優缺點分析
- 最實用的機器學習演算法優缺點分析機器學習演算法
- JaCoCo 企業級應用的優缺點分析
- Android Volley 原始碼解析（三），圖片載入的實現Android原始碼
- 節點快取的優缺點快取
- MyBatis的優缺點以及特點MyBatis
- Android 原始碼分析之 AsyncTask 原始碼分析Android原始碼
- 分享6個Java框架及優缺點介紹Java框架
- 單例模式的五種實現方式及優缺點單例模式
- Bash 和 Python 程式語言優缺點分析Python