Volley源码解析(一)
来源:互联网 发布:上海零境网络 起诉 编辑:程序博客网 时间:2024/05/19 13:24
之前看过郭神的blog,今天也是着按照自己的思路走一遍Volley框架中关于Http请求的源码
首先还是引用一下郭神的图,清楚的阐述了当网络连接请求到来时的工作机制
缓存这个东西几乎是无处不在,无论我们从事的是什么计算机的方向,都对性能优化有着至关重要的作用。
可以看到架构图中,当request到来时,首先判断是否已经缓存过,如果没有直接加入network中,然后是一系列的http的解析等工作,下面会通过源码来详细解析。如果已经缓存过,就从缓存队列中读取并解析。最后把解析结果回调给主线程完成http请求响应工作。
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. * @return A started {@link RequestQueue} instance. */ public static RequestQueue newRequestQueue(Context context) { return newRequestQueue(context, null); }
从注释中可以清晰的看到,这是创建RequestQueue实例的起点,会调用另一个newRequestQueue的方法,那就跟进去一起看一下。
然而蛋疼的是:
/** * 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) { return newRequestQueue(context, stack, -1); }
another method appear。这里可以发现,当我们只是创建RequestQueue的时候,其实就是把第二个方法的HttpStack参数传入null值。
第三个参数的意思是是否使用DiskCache,默认的话我们使用内存缓存,应该是不使用磁盘缓存的吧。
继续跟进!
/** * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it. * You may set a maximum size of the disk cache in bytes. * * @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. * @param maxDiskCacheBytes the maximum size of the disk cache, in bytes. Use -1 for default size. * @return A started {@link RequestQueue} instance. */ public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) { 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; if (maxDiskCacheBytes <= -1) { // No maximum size specified queue = new RequestQueue(new DiskBasedCache(cacheDir), network); } else { // Disk cache size specified queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network); } queue.start(); return queue; }
这段代码中的
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)); } }
首先判断传入的httpstack是否为空,如果为null,然后再去判断系统的版本号选择性的创建HurlStack还是HttpClientStack。从注释中看到,当在Gingerbread版本之前的Android系统里面,HttpUrlConnection是不受信任的,不安全的。当对一个可读的InputStream进行close的时候,用于管理多个长连接的连接池可能也会因此失效。
接下来创建一个Network用于根据传入的HttpStack对象处理网络请求
Network network = new BasicNetwork(stack);
跟进去看一下BasicNetwork的构造方法
public class BasicNetwork implements Network { protected static final boolean DEBUG = VolleyLog.DEBUG; private static int SLOW_REQUEST_THRESHOLD_MS = 3000; private static int DEFAULT_POOL_SIZE = 4096; protected final HttpStack mHttpStack; protected final ByteArrayPool mPool; /** * @param httpStack HTTP stack to be used */ public BasicNetwork(HttpStack httpStack) { // If a pool isn't passed in, then build a small default pool that will give us a lot of // benefit and not use too much memory. this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE)); } /** * @param httpStack HTTP stack to be used * @param pool a buffer pool that improves GC performance in copy operations */ public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) { mHttpStack = httpStack; mPool = pool; }
构造方法主要涵盖了两个参数HttpStack、字节缓冲区(用于改善在复制操作时GC的性能)。如果没有传入字节缓冲区的参数,就构造一个默认大小的缓冲区。跳出BasicNetwork的源码,继续来看上面的源码。在创建出Network对象后,在判断我们是否指定了DiskCache之后,new出一个RequestQueue对象并调用start(),最后返回RequestQueue。
跟进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()。随后循环创建NetworkDispatcher并调用start()。CacheDispatcher与NetworkDispatcher都是继承的是线程
public class NetworkDispatcher extends Thread
public class CacheDispatcher extends Thread
所以说当我们从一开始创建RequestQueue实例开始,直到现在,会分别创建NetworkDispatcher与CacheDispatcher线程用于处理网络请求。
回想我们使用Volley框架时的方法,首先构建RequestQueue,然后我们就把request加入到RequestQueue当中
/** * 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.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; } }
我们将所有发送过来的请求消息单独构建一个HashSet进行存储,之所以用HashSet因为我们没有必要重复记录相同的request,所以通过HashSet去重。
private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
然后给每个request设置sequenceNumber。随后判断当前请求是否可以缓存,如果不能缓存就加入网络请求队列,如果可以缓存,首先拿到request的cacheKey,判断HashSet中是否已经包括的相同的cacheKey。如果没有的话就把这条请求加入缓存队列。默认情况下,每条请求都是可以缓存的,所以重点关注CacheDispatcher的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(); Request<?> request; while (true) { // release previous request object to avoid leaking request object when mQueue is drained. request = null; try { // Take a request from the queue. request = mCacheQueue.take(); } catch (InterruptedException e) { // We may have been interrupted because it was time to quit. if (mQuit) { return; } continue; } try { 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. final Request<?> finalRequest = request; mDelivery.postResponse(request, response, new Runnable() { @Override public void run() { try { mNetworkQueue.put(finalRequest); } catch (InterruptedException e) { // Not much we can do about this. } } }); } } catch (Exception e) { VolleyLog.e(e, "Unhandled exception %s", e.toString()); } } }
try { // Take a request from the queue. request = mCacheQueue.take(); } catch (InterruptedException e) { // We may have been interrupted because it was time to quit. if (mQuit) { return; } continue; }
阻塞式的从缓存队列中取出request。接着会根据request的cachekey从缓存中取出响应结果,如果为空就将这个请求加入到NetworkDispatcher。如果不为空还要判断缓存是否过期,过期同样的把request加入到NetworkDispatcher。那么NetworkDispaer中如何处理到来的请求:
@Override public void run() { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); Request<?> request; while (true) { long startTimeMs = SystemClock.elapsedRealtime(); // release previous request object to avoid leaking request object when mQueue is drained. request = null; 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"); ...
重点看
NetworkResponse networkResponse = mNetwork.performRequest(request);
执行的是BasicNetwork中的performRequest方法,继续跟进
@Override public NetworkResponse performRequest(Request<?> request) throws VolleyError { long requestStart = SystemClock.elapsedRealtime(); while (true) { HttpResponse httpResponse = null; byte[] responseContents = null; Map<String, String> responseHeaders = Collections.emptyMap(); 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(); ...
我们看到
httpResponse = mHttpStack.performRequest(request, headers);
其实最终的原理就是调用HttpClient或者HttpURLConnection来发送网络请求,Volley框架对其进行了完美的封装。那么发送网络请求之后,自然地就返回NetworkResponse,紧接着在NetworkDispatcher中调用
Response<?> response = request.parseNetworkResponse(networkResponse);
对NetworkResponse中的数据进行解析。随后,回调解析后的数据
// Post the response back. request.markDelivered(); mDelivery.postResponse(request, response);
@Override 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()方法中的代码是什么样的:
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(); } }
如果Response成功解析出来的话,调用deliverResponse(result),通过重写这个方法可以把响应result传入Response.Listener的onResponse()方法中,然后在onResponse()方法中处理响应的result。
例如在StringQuest中使用:
StringRequest stringRequest = new StringRequest("http://www.baidu.com", new Response.Listener<String>() { @Override public void onResponse(String response) { Log.d("TAG", response); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { Log.e("TAG", error.getMessage(), error); } });
到这里,源码解析基本上也就结束了。
参考http://blog.csdn.net/guolin_blog/article/details/17656437
新人试手,如有错误,欢迎指正
- Volley源码解析(一)
- Volley源码解析(一)
- Volley源码解析(一)
- Volley学习(一)Android Volley源码解析
- Volley 源码解析(一)
- Volley源码解析(一)
- 【Volley】Volley源码解析
- Volley源码解析<一> 代码准备
- Volley源码解析(一),基本概述
- volley源码解析(一)--volley的使用和架构
- Volley源码解析(一)Volley中乱码问题及解决方案
- volley源码解析(一)--volley的使用和架构
- volley源码解析
- Volley 源码解析
- Volley 源码解析
- Volley 源码解析
- Volley 源码解析
- Volley 源码解析
- 栈的应用举例
- 3-31博客
- 对接收数组参数的成员方法进行反射
- C++里的虚函数
- Socket编程-UDP协议
- Volley源码解析(一)
- SQL中的各种连接及查询
- 网站建设(3)——CDN及CDN加速原理
- OpenCV打开摄像头出现运行错误OpenCV Error:Assertion failed (size.width>0&&size.height>0)in cv::imshow,……
- 码农小汪-剑指Offer之30 -把数组排成最小的数(拼接字符串排序)
- 程序员真正的价值
- SPOJ QTREE Query on a tree (lct)
- 数组与Object的关系及其反射类型
- 产品经理职业分享以及求职技巧讲座