Android開源框架Volley(Google IO 2013)源代碼及內部實現分析

1.Volley概述

在項目開發過程當中，博主曾寫過大量的訪問網絡重複代碼，特別是ListView adapter很難避免getView()方法不被重複調用，若是ImageView不利用緩存機制，那麼網絡的負荷就會更大！曾將訪問網絡代碼和緩存封裝起來使用，可是中間仍存在很多瑕疵！今年的Google I/O 2013上，Volley發佈了！Volley是Android平臺上的網絡通訊庫，能使網絡通訊更快，更簡單，更健壯

SouthEast.jpg (145.72 KB, 下載次數: 0)

下載附件  保存到相冊

昨天 16:24 上傳

Volley特別適合數據量不大可是通訊頻繁的場景，如今android提供的源碼已經包含Volley，之後在項目中，能夠根據需求引入Volley jar文件！

2.Volley源碼分析

(1).Volley.java

Volley.newRequestQueue()方法在一個app最好執行一次，可使用單例設計模式或者在application完成初始化，具體緣由請查看代碼分析

1. /**
   
2. * @author zimo2013
   
3. * [url=home.php?mod=space&uid=189949]@See[/url] http://blog.csdn.net/zimo2013
   
4. */
   
5. public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
   
6.     File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
   
7. 
   
8.     String userAgent = "volley/0";
   
9.     try {
   
10.         String packageName = context.getPackageName();
    
11.         PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
    
12.         userAgent = packageName + "/" + info.versionCode;
    
13.     } catch (NameNotFoundException e) {
    
14.     }
    
15. 
    
16.     if (stack == null) {
    
17.         if (Build.VERSION.SDK_INT >= 9) {
    
18.             stack = new HurlStack();
    
19.         } else {
    
20.             stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
    
21.         }
    
22.     }
    
23. 
    
24.     Network network = new BasicNetwork(stack);
    
25. 
    
26.     //cacheDir 緩存路徑 /data/data/<pkg name>/cache/<name>
    
27.     RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
    
28.     queue.start();
    
29.     /*
    
30.      * 實例化一個RequestQueue，其中start()主要完成相關工做線程的開啓，
    
31.      * 好比開啓緩存線程CacheDispatcher先完成緩存文件的掃描， 還包括開啓多個NetworkDispatcher訪問網絡線程，
    
32.      * 該多個網絡線程將從 同一個 網絡阻塞隊列中讀取消息
    
33.      *
    
34.      * 此處可見，start()已經開啓，全部咱們不用手動的去調用該方法，在start()方法中若是存在工做線程應該首先終止，並從新實例化工做線程並開啓
    
35.      * 在訪問網絡很頻繁，而又重複調用start()，勢必會致使性能的消耗；可是若是在訪問網絡不多時，調用stop()方法，中止多個線程，而後調用start(),反而又能夠提升性能，具體可折中選擇
    
36.      */
    
37. 
    
38.     return queue;
    
39. }

複製代碼

(2).RequestQueue.java

1. /**
   
2. * RequestQueue類存在2個很是重要的PriorityBlockingQueue類型的成員字段mCacheQueue mNetworkQueue ，該PriorityBlockingQueue爲java1.5併發庫提供的新類
   
3. * 其中有幾個重要的方法，好比take()爲從隊列中取得對象，若是隊列不存在對象，將會被阻塞，直到隊列中存在有對象，相似於Looper.loop()
   
4. *
   
5. * 實例化一個request對象，調用RequestQueue.add(request),該request若是不容許被緩存，將會被添加至mNetworkQueue隊列中，待多個NetworkDispatcher線程take()取出對象
   
6. * 若是該request能夠被緩存，該request將會被添加至mCacheQueue隊列中，待mCacheDispatcher線程從mCacheQueue.take()取出對象，
   
7. * 若是該request在mCache中不存在匹配的緩存時，該request將會被移交添加至mNetworkQueue隊列中，待網絡訪問完成後，將關鍵頭信息添加至mCache緩存中去！
   
8. *
   
9. * @author zimo2013
   
10. * @see http://blog.csdn.net/zimo2013
    
11. */
    
12. public void start() {
    
13.     stop();
    
14.    
    
15.     mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
    
16.     mCacheDispatcher.start();
    
17. 
    
18.     // Create network dispatchers (and corresponding threads) up to the pool size.
    
19.     for (int i = 0; i < mDispatchers.length; i++) {
    
20.         NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
    
21.                 mCache, mDelivery);
    
22.         mDispatchers[i] = networkDispatcher;
    
23.         networkDispatcher.start();
    
24.     }
    
25. }

複製代碼

(3).CacheDispatcher.java

1. /**
   
2. * @author zimo2013
   
3. * @see http://blog.csdn.net/zimo2013
   
4. */
   
5. @Override
   
6. public void run() {
   
7.     Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
   
8. 
   
9.     //緩存初始化，會遍歷整個緩存文件夾
   
10.     mCache.initialize();
    
11.     {
    
12.             //執行代碼
    
13.             /*if (!mRootDirectory.exists()) {
    
14.             if (!mRootDirectory.mkdirs()) {
    
15.                 VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
    
16.             }
    
17.             return;
    
18.         }
    
19. 
    
20.         File[] files = mRootDirectory.listFiles();
    
21.         if (files == null) {
    
22.             return;
    
23.         }
    
24.         for (File file : files) {
    
25.             FileInputStream fis = null;
    
26.             try {
    
27.                 fis = new FileInputStream(file);
    
28.                 CacheHeader entry = CacheHeader.readHeader(fis);
    
29.                 entry.size = file.length();
    
30.                 putEntry(entry.key, entry);
    
31.             } catch (IOException e) {
    
32.                 if (file != null) {
    
33.                    file.delete();
    
34.                 }
    
35.             } finally {
    
36.                 try {
    
37.                     if (fis != null) {
    
38.                         fis.close();
    
39.                     }
    
40.                 } catch (IOException ignored) { }
    
41.             }
    
42.         }*/
    
43.     }
    
44. 
    
45.     while (true) {
    
46.         try {
    
47.                 //該方法可能會被阻塞
    
48.             final Request request = mCacheQueue.take();
    
49. 
    
50.             Cache.Entry entry = mCache.get(request.getCacheKey());
    
51.             if (entry == null) {
    
52.                     //緩存不存在，則將該request添加至網絡隊列中
    
53.                 mNetworkQueue.put(request);
    
54.                 continue;
    
55.             }
    
56. 
    
57.             //是否已通過期
    
58.             if (entry.isExpired()) {
    
59.                 request.setCacheEntry(entry);
    
60.                 mNetworkQueue.put(request);
    
61.                 continue;
    
62.             }
    
63. 
    
64.             Response<?> response = request.parseNetworkResponse(
    
65.                     new NetworkResponse(entry.data, entry.responseHeaders));
    
66. 
    
67.             //存在緩存，執行相關操做
    
68. 
    
69.         } catch (InterruptedException e) {
    
70.         }
    
71.     }
    
72. }

複製代碼

(4).NetworkDispatcher.java

1. /**
   
2. * @author zimo2013
   
3. * @see http://blog.csdn.net/zimo2013
   
4. */
   
5. @Override
   
6. public void run() {
   
7.     Request request;
   
8.     while (true) {
   
9.         try {
   
10.                 //可能會被
    
11.             request = mQueue.take();
    
12.         } catch (InterruptedException e) {
    
13.             // We may have been interrupted because it was time to quit.
    
14.             if (mQuit) {
    
15.                 return;
    
16.             }
    
17.             continue;
    
18.         }
    
19. 
    
20.         try {
    
21.                
    
22.                 //訪問網絡，獲得數據
    
23.             NetworkResponse networkResponse = mNetwork.performRequest(request);
    
24. 
    
25.             if (networkResponse.notModified && request.hasHadResponseDelivered()) {
    
26.                 request.finish("not-modified");
    
27.                 continue;
    
28.             }
    
29. 
    
30.             // Parse the response here on the worker thread.
    
31.             Response<?> response = request.parseNetworkResponse(networkResponse);
    
32. 
    
33.             // 寫入緩存
    
34.             if (request.shouldCache() && response.cacheEntry != null) {
    
35.                 mCache.put(request.getCacheKey(), response.cacheEntry);
    
36.                 request.addMarker("network-cache-written");
    
37.             }
    
38. 
    
39.             // Post the response back.
    
40.             request.markDelivered();
    
41.             mDelivery.postResponse(request, response);
    
42.         } catch (VolleyError volleyError) {
    
43.             parseAndDeliverNetworkError(request, volleyError);
    
44.         } catch (Exception e) {
    
45.             VolleyLog.e(e, "Unhandled exception %s", e.toString());
    
46.             mDelivery.postError(request, new VolleyError(e));
    
47.         }
    
48.     }
    
49. }

複製代碼

(5).StringRequest.java

其中在parseNetworkResponse()中，完成將byte[]到String的轉化,可能會出現字符亂碼，HttpHeaderParser.parseCharset(response.headers)方法在還沒有指定是返回爲ISO-8859-1，能夠修改成 utf-8

1. public class StringRequest extends Request<String> {
   
2.     private final Listener<String> mListener;
   
3. 
   
4.     /**
   
5.      * Creates a new request with the given method.
   
6.      *
   
7.      * @param method the request {@link Method} to use
   
8.      * @param url URL to fetch the string at
   
9.      * @param listener Listener to receive the String response
   
10.      * @param errorListener Error listener, or null to ignore errors
    
11.      */
    
12.     public StringRequest(int method, String url, Listener<String> listener,
    
13.             ErrorListener errorListener) {
    
14.         super(method, url, errorListener);
    
15.         mListener = listener;
    
16.     }
    
17. 
    
18.     public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
    
19.         this(Method.GET, url, listener, errorListener);
    
20.     }
    
21. 
    
22.     @Override
    
23.     protected void deliverResponse(String response) {
    
24.         mListener.onResponse(response);
    
25.     }
    
26. 
    
27.     @Override
    
28.     protected Response<String> parseNetworkResponse(NetworkResponse response) {
    
29.         String parsed;
    
30.         try {
    
31.                 //將data字節數據轉化爲String對象
    
32.             parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
    
33.         } catch (UnsupportedEncodingException e) {
    
34.             parsed = new String(response.data);
    
35.         }
    
36.         //返回Response對象，其中該對象包含訪問相關數據
    
37.         return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    
38.     }
    
39. }

複製代碼

(6).ImageLoader.java

1. /**
   
2. * @author zimo2013
   
3. * @see http://blog.csdn.net/zimo2013
   
4. */
   
5. public ImageContainer get(String requestUrl, ImageListener imageListener,
   
6.         int maxWidth, int maxHeight) {
   
7.     throwIfNotOnMainThread();
   
8.     final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);
   
9. 
   
10.     //從mCache獲得bitmap對象，所以能夠覆寫ImageCache，完成圖片的三級緩存，即在原有的LruCache添加一個軟引用緩存
    
11.     Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
    
12.     if (cachedBitmap != null) {
    
13.             //獲得緩存對象
    
14.         ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
    
15.         imageListener.onResponse(container, true);
    
16.         return container;
    
17.     }
    
18. 
    
19.     ImageContainer imageContainer =
    
20.             new ImageContainer(null, requestUrl, cacheKey, imageListener);
    
21. 
    
22.     // 首先更新該view，其指定了defaultImage
    
23.     imageListener.onResponse(imageContainer, true);
    
24. 
    
25.     // 根據能夠去檢查該請求是否已經發起過
    
26.     BatchedImageRequest request = mInFlightRequests.get(cacheKey);
    
27.     if (request != null) {
    
28.         request.addContainer(imageContainer);
    
29.         return imageContainer;
    
30.     }
    
31. 
    
32.     Request<?> newRequest =
    
33.         new ImageRequest(requestUrl, new Listener<Bitmap>() {
    
34.             @Override
    
35.             public void onResponse(Bitmap response) {
    
36.                     //若是請求成功
    
37.                 onGetImageSuccess(cacheKey, response);
    
38.             }
    
39.         }, maxWidth, maxHeight,
    
40.         Config.RGB_565, new ErrorListener() {
    
41.             @Override
    
42.             public void onErrorResponse(VolleyError error) {
    
43.                 onGetImageError(cacheKey, error);
    
44.             }
    
45.         });
    
46.     //添加至請求隊列中
    
47.     mRequestQueue.add(newRequest);
    
48.     //同一添加進map集合，以方便檢查該request是否正在請求網絡，能夠節約資源
    
49.     mInFlightRequests.put(cacheKey, new BatchedImageRequest(newRequest, imageContainer));
    
50.     return imageContainer;
    
51. }

複製代碼

1. private void onGetImageSuccess(String cacheKey, Bitmap response) {
   
2.         //緩存對象
   
3.     mCache.putBitmap(cacheKey, response);
   
4. 
   
5.     // 請求完成，不須要檢測
   
6.     BatchedImageRequest request = mInFlightRequests.remove(cacheKey);
   
7. 
   
8.     if (request != null) {
   
9.         request.mResponseBitmap = response;
   
10.         //處理結果
    
11.         batchResponse(cacheKey, request);
    
12.     }
    
13. }

複製代碼

1. private void batchResponse(String cacheKey, BatchedImageRequest request) {
   
2.     mBatchedResponses.put(cacheKey, request);
   
3.     //經過handler，發送一個操做
   
4.     if (mRunnable == null) {
   
5.         mRunnable = new Runnable() {
   
6.             @Override
   
7.             public void run() {
   
8.                 for (BatchedImageRequest bir : mBatchedResponses.values()) {
   
9.                     for (ImageContainer container : bir.mContainers) {
   
10.                         if (container.mListener == null) {
    
11.                             continue;
    
12.                         }
    
13.                         if (bir.getError() == null) {
    
14.                             container.mBitmap = bir.mResponseBitmap;
    
15.                             //更新結果
    
16.                             container.mListener.onResponse(container, false);
    
17.                         } else {
    
18.                             container.mListener.onErrorResponse(bir.getError());
    
19.                         }
    
20.                     }
    
21.                 }
    
22.                 mBatchedResponses.clear();
    
23.                 mRunnable = null;
    
24.             }
    
25. 
    
26.         };
    
27.         // mHandler對應的looper是MainLooper，所以被MainLooper.loop()獲得該message，故該runnable操做在主線程中執行，
    
28.         mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
    
29.     }
    
30. }

複製代碼

3.總結

SouthEast.jpg (187.99 KB, 下載次數: 0)

下載附件  保存到相冊

昨天 16:24 上傳

RequestQueue類存在2個很是重要的PriorityBlockingQueue類型的成員字段mCacheQueue mNetworkQueue ，該PriorityBlockingQueue爲java1.5併發庫提供的！其中有幾個重要的方法，好比take()爲從隊列中取得對象，若是隊列不存在對象，將會被阻塞，直到隊列中存在有對象，相似於Looper.loop()。實例化一個request對象，調用RequestQueue.add(request),該request若是不容許被緩存，將會被添加至mNetworkQueue隊列中，待多個NetworkDispatcher線程從mNetworkQueue中take()取出對象。若是該request能夠被緩存，該request將會被添加至mCacheQueue隊列中，待mCacheDispatcher線程從mCacheQueue.take()取出對象，若是該request在mCache中不存在匹配的緩存時，該request將會被移交添加至mNetworkQueue隊列中，待網絡訪問完成後，將關鍵頭信息添加至mCache緩存中去，並經過ResponseDelivery主線程調用request的相關方法！Volley實例