Android开源框架Volley(Google IO 2013)源代码及内部实现分析

1.Volley概述

在项目开发过 程中，博主曾写过大量的访问网络重复代码，特别是ListView adapter很难避免getView()方法不被重复调用，如果ImageView不利用缓存机制，那么网络的负荷就会更大！曾将访问网络代码和缓存封 装起来使用，但是中间仍存在不少瑕疵！今年的Google I/O 2013上，Volley发布了！Volley是Android平台上的网络通信库，能使网络通信更快，更简单，更健壮

Volley特别适合数据量不大但是通信频繁的场景，现在android提供的源码已经包含Volley，以后在项目中，可以根据需求引入Volley jar文件！

2.Volley源码分析(1).Volley.javaVolley.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. String userAgent = "volley/0";
8. try {
9. String packageName = context.getPackageName();
10. PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
11. userAgent = packageName + "/" + info.versionCode;
12. } catch (NameNotFoundException e) {
13. }
14. if (stack == null) {
15. if (Build.VERSION.SDK_INT >= 9) {
16. stack = new HurlStack();
17. } else {
18. stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
19. }
20. }
21. Network network = new BasicNetwork(stack);
22. //cacheDir 缓存路径 /data/data/<pkg name>/cache/<name>
23. RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
24. queue.start();
25. /*
26. * 实例化一个RequestQueue，其中start()主要完成相关工作线程的开启，
27. * 比如开启缓存线程CacheDispatcher先完成缓存文件的扫描， 还包括开启多个NetworkDispatcher访问网络线程，
28. * 该多个网络线程将从 同一个 网络阻塞队列中读取消息
29. *
30. * 此处可见，start()已经开启，所有我们不用手动的去调用该方法，在start()方法中如果存在工作线程应该首先终止，并重新实例化工作线程并开启
31. * 在访问网络很频繁，而又重复调用start()，势必会导致性能的消耗；但是如果在访问网络很少时，调用stop()方法，停止多个线程，然后调用start(),反而又可以提高性能，具体可折中选择
32. */
33. return queue;
34. }

复制代码

(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. mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
15. mCacheDispatcher.start();
16. // Create network dispatchers (and corresponding threads) up to the pool size.
17. for (int i = 0; i < mDispatchers.length; i++) {
18. NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
19. mCache, mDelivery);
20. mDispatchers[i] = networkDispatcher;
21. networkDispatcher.start();
22. }
23. }

复制代码

(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. mCache.initialize();
10. {
11. //执行代码
12. /*if (!mRootDirectory.exists()) {
13. if (!mRootDirectory.mkdirs()) {
14. VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
15. }
16. return;
17. }
18. File[] files = mRootDirectory.listFiles();
19. if (files == null) {
20. return;
21. }
22. for (File file : files) {
23. FileInputStream fis = null;
24. try {
25. fis = new FileInputStream(file);
26. CacheHeader entry = CacheHeader.readHeader(fis);
27. entry.size = file.length();
28. putEntry(entry.key, entry);
29. } catch (IOException e) {
30. if (file != null) {
31. file.delete();
32. }
33. } finally {
34. try {
35. if (fis != null) {
36. fis.close();
37. }
38. } catch (IOException ignored) { }
39. }
40. }*/
41. }
42. while (true) {
43. try {
44. //该方法可能会被阻塞
45. final Request request = mCacheQueue.take();
46. Cache.Entry entry = mCache.get(request.getCacheKey());
47. if (entry == null) {
48. //缓存不存在，则将该request添加至网络队列中
49. mNetworkQueue.put(request);
50. continue;
51. }
52. //是否已经过期
53. if (entry.isExpired()) {
54. request.setCacheEntry(entry);
55. mNetworkQueue.put(request);
56. continue;
57. }
58. Response<?> response = request.parseNetworkResponse(
59. new NetworkResponse(entry.data, entry.responseHeaders));
60. //存在缓存，执行相关操作
61. } catch (InterruptedException e) {
62. }
63. }
64. }

复制代码

(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. try {
20. //访问网络，得到数据
21. NetworkResponse networkResponse = mNetwork.performRequest(request);
22. if (networkResponse.notModified && request.hasHadResponseDelivered()) {
23. request.finish("not-modified");
24. continue;
25. }
26. // Parse the response here on the worker thread.
27. Response<?> response = request.parseNetworkResponse(networkResponse);
28. // 写入缓存
29. if (request.shouldCache() && response.cacheEntry != null) {
30. mCache.put(request.getCacheKey(), response.cacheEntry);
31. request.addMarker("network-cache-written");
32. }
33. // Post the response back.
34. request.markDelivered();
35. mDelivery.postResponse(request, response);
36. } catch (VolleyError volleyError) {
37. parseAndDeliverNetworkError(request, volleyError);
38. } catch (Exception e) {
39. VolleyLog.e(e, "Unhandled exception %s", e.toString());
40. mDelivery.postError(request, new VolleyError(e));
41. }
42. }
43. }

复制代码

(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. * Creates a new request with the given method.
5. *
6. * @param method the request {@link Method} to use
7. * @param url URL to fetch the string at
8. * @param listener Listener to receive the String response
9. * @param errorListener Error listener, or null to ignore errors
10. */
11. public StringRequest(int method, String url, Listener<String> listener,
12. ErrorListener errorListener) {
13. super(method, url, errorListener);
14. mListener = listener;
15. }
16. public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
17. this(Method.GET, url, listener, errorListener);
18. }
19. @Override
20. protected void deliverResponse(String response) {
21. mListener.onResponse(response);
22. }
23. @Override
24. protected Response<String> parseNetworkResponse(NetworkResponse response) {
25. String parsed;
26. try {
27. //将data字节数据转化为String对象
28. parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
29. } catch (UnsupportedEncodingException e) {
30. parsed = new String(response.data);
31. }
32. //返回Response对象，其中该对象包含访问相关数据
33. return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
34. }
35. }

复制代码

(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. //从mCache得到bitmap对象，因此可以覆写ImageCache，完成图片的三级缓存，即在原有的LruCache添加一个软引用缓存
10. Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
11. if (cachedBitmap != null) {
12. //得到缓存对象
13. ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
14. imageListener.onResponse(container, true);
15. return container;
16. }
17. ImageContainer imageContainer =
18. new ImageContainer(null, requestUrl, cacheKey, imageListener);
19. // 首先更新该view，其指定了defaultImage
20. imageListener.onResponse(imageContainer, true);
21. // 根据可以去检查该请求是否已经发起过
22. BatchedImageRequest request = mInFlightRequests.get(cacheKey);
23. if (request != null) {
24. request.addContainer(imageContainer);
25. return imageContainer;
26. }
27. Request<?> newRequest =
28. new ImageRequest(requestUrl, new Listener<Bitmap>() {
29. @Override
30. public void onResponse(Bitmap response) {
31. //如果请求成功
32. onGetImageSuccess(cacheKey, response);
33. }
34. }, maxWidth, maxHeight,
35. Config.RGB_565, new ErrorListener() {
36. @Override
37. public void onErrorResponse(VolleyError error) {
38. onGetImageError(cacheKey, error);
39. }
40. });
41. //添加至请求队列中
42. mRequestQueue.add(newRequest);
43. //同一添加进map集合，以方便检查该request是否正在请求网络，可以节约资源
44. mInFlightRequests.put(cacheKey, new BatchedImageRequest(newRequest, imageContainer));
45. return imageContainer;
46. }

复制代码

1. private void onGetImageSuccess(String cacheKey, Bitmap response) {
2. //缓存对象
3. mCache.putBitmap(cacheKey, response);
4. // 请求完成，不需要检测
5. BatchedImageRequest request = mInFlightRequests.remove(cacheKey);
6. if (request != null) {
7. request.mResponseBitmap = response;
8. //处理结果
9. batchResponse(cacheKey, request);
10. }
11. }

复制代码

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. // mHandler对应的looper是MainLooper，因此被MainLooper.loop()得到该message，故该runnable操作在主线程中执行，
27. mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
28. }
29. }

复制代码

3.总结

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实例