volley 阅读笔记：
====================================================================================================
Volley 类
只是提供了 newRequestQueue 方法。
在 newRequestQueue 方法中，根据版本自动选择网络实现方式：
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 :
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();
====================================================================================================
Network 接口
public NetworkResponse performRequest(Request<?> request) throws VolleyError;
这个方法主要是调用了 HttpStack 的 performRequest 方法，其他的就是处理了请求头和响应头，以及返回码的处理。
如 304， 301， 302 等。
里面的重定向是通过重试策略来处理的：
if (statusCode < 200 || statusCode > 299) {
throw new IOException();
}
然后捕获异常，分别处理：
} catch (IOException e) {
...
if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||
statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
attemptRetryOnException("redirect",
request, new RedirectError(networkResponse));
}
...
}
实现类为BasicNetWork
====================================================================================================
RequestQueue 类
// 这个 map 里面存储的是 重复请求
// 请求的缓存 key 相同，则放入缓存 key 对应的队列，如果没有队列则新建一个队列
private final Map<String, Queue<Request<?>>> mWaitingRequests =
new HashMap<String, Queue<Request<?>>>();
核心方法：
public void start() {}
将 CacheDispatcher 和 NetworkDispatcher 给启动起来
public void cancelAll(final Object tag) {}
取消 tag 匹配的请求，方法里面用到了过滤器的方法 -- public void cancelAll(RequestFilter filter) {} --
public <T> Request<T> add(Request<T> request) {}
将 Request 添加到 RequestQueue 中
添加过程：
1.先添加到集合(mCurrentRequests，这个集合保存队列所有请求)中，
synchronized (mCurrentRequests) {
mCurrentRequests.add(request);
}
2.判断该请求是否缓存，不缓存则直接添加到网络请求队列
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}
3.需要缓存，从等待队列里面找出缓存key相同的请求，放入对应的等待队列中
private final Map<String, Queue<Request<?>>> mWaitingRequests =
new HashMap<String, Queue<Request<?>>>();
mWaitingRequests 是一个url，对应着一个队列。说明有一个请求重复执行多次。
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;
====================================================================================================
HttpStack 接口
public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
throws IOException, AuthFailureError;
这个方法实际上就是我们平时写的网络请求，只不过考虑的细节更多。
有两个实现类，HttpClientStack 和 HurlStack
有两个实现是因为：Prior to Gingerbread, HttpUrlConnection was unreliable.
HurlStack是封装的HttpUrlConnection，google团队会将优化精力放在这个类上面，推荐使用这个。
====================================================================================================
CacheDispatcher 类
CacheDispatcher 继承 Thread
看 run 方法
public void run() {}
1.设置线程优先级：Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
2.初始化缓存 mCache.initialize();
3.开启一个死循环 while (true) { ... }
4.取出一个请求，如果该请求被取消，则 finish 这个请求，继续下一个循环
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
5.未取消，则通过请求缓存的 key 值取出相应的缓存：Cache.Entry entry = mCache.get(request.getCacheKey());
6.取出的缓存为 null，将该请求放入网络请求队列中去执行，继续下一个循环：
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
mNetworkQueue.put(request);
continue;
}
7.缓存不为 null，但是过期了，将请求放入网络请求队列中执行，继续下一个循环：
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}
8.将缓存封装成响应结果：
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
9.如果缓存不需要更新，直接将请求响应分发出去（一般是主线程）
mDelivery.postResponse(request, response);
10.缓存需要更新，将请求放入网络请求队列
// 设置缓存
request.setCacheEntry(entry);
// Mark the response as intermediate.
// 设置这个玩意，表示在分发请求响应之后不会finish这个请求，因为这个缓存需要更新
// 这个请求会被放到网络请求队列中执行
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.
}
}
});
====================================================================================================
NetworkDispatcher 类
NetworkDispatcher 继承 Thread
和 CacheDispatcher 基本差不多
1.遇到304，如果请求响应结果已经被分发出去了，结束这个请求，继续下一个循环：
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}
2.解析网络请求：
Response<?> response = request.parseNetworkResponse(networkResponse);
具体的解析方式，与请求有关，如果是 JsonRequest，就解析成 Json。
3.如果请求需要缓存，并且相应中有数据，则储存缓存
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
4.记录响应已经被分发出去，分发响应，出错则分发错误：
request.markDelivered();
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
====================================================================================================
ResponseDelivery 接口
/**
* Parses a response from the network or cache and delivers it.
*/
public void postResponse(Request<?> request, Response<?> response);
/**
* Parses a response from the network or cache and delivers it. The provided
* Runnable will be executed after delivery.
*/
public void postResponse(Request<?> request, Response<?> response, Runnable runnable);
/**
* Posts an error for the given request.
*/
public void postError(Request<?> request, VolleyError error);
提供了分发请求响应结果和错误的方法。
ExecutorDelivery 为实现类
实际上是利用 Handler post 了一个 Runnable :
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
// 获取主线程的Handler
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
// 实例化Executor
public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
}
};
}
// 分发请求响应
@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}
// 请求被取消，结束请求，返回
// 响应成功，分发请求响应
// 响应失败，分发错误
// 响应执行完，结束请求，未执行完（mResponse.intermediate）不做操作
// 执行runnable里面的代码
@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();
}
}
====================================================================================================
RequestQueue 和 CacheDispatcher 和 NetworkDispatcher
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}
public CacheDispatcher(
BlockingQueue<Request<?>> cacheQueue, BlockingQueue<Request<?>> networkQueue,
Cache cache, ResponseDelivery delivery) {
mCacheQueue = cacheQueue;
mNetworkQueue = networkQueue;
mCache = cache;
mDelivery = delivery;
}
public NetworkDispatcher(BlockingQueue<Request<?>> queue,
Network network, Cache cache,
ResponseDelivery delivery) {
mQueue = queue;
mNetwork = network;
mCache = cache;
mDelivery = delivery;
}
如何关联的？？？
Volley 类中：
...
RequestQueue queue;
...
queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
...
queue.start();
看 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();
}
}
mCacheQueue 为 PriorityBlockingQueue<Request<?>>
有初始值，且在 public <T> Request<T> add(Request<T> request) {} 方法中：
mCacheQueue.add(request);
mNetworkQueue 为 PriorityBlockingQueue<Request<?>>
有初始值，且在 public <T> Request<T> add(Request<T> request) {} 方法中：
mNetworkQueue.add(request);
mCache 为 DiskBasedCache 构造函数中赋值
public NetworkDispatcher(BlockingQueue<Request<?>> queue,
Network network, Cache cache,
ResponseDelivery delivery) {
...
mCache = cache;
...
}
我们在主线程发出的请求，如StringRequest，add 到 RequestQueue 中，
RequestQueue 会根据请求是否缓存，是否已经有该请求的缓存等来判断是添加到 NetworkQueue 还是 CacheQueue。
NetworkDispatcher 和 CacheDispatcher 在 RequestQueue 启动时就在运行，分别从 NetworkQueue 和 CacheQueue
中取出请求，进行处理，处理完成的结果，由 ExecutorDelivery 进行分发到主线程。
网络的处理：
NetworkResponse networkResponse = mNetwork.performRequest(request);
利用 BasicNetwork 执行请求，获取网络响应。
Response<?> response = request.parseNetworkResponse(networkResponse);
利用对应的请求，将网络响应解析称对应的数据。如 StringRequest，则解析成 String。
缓存的处理：
Cache.Entry entry = mCache.get(request.getCacheKey());
根据请求的缓存 key 值，拿出请求对应的缓存。
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
利用对应的请求，将网络响应解析称对应的数据。如 StringRequest，则解析成 String。
====================================================================================================
DiskBasedCache 类
实现了 Cache 接口
Volley 只有磁盘缓存，没有内存缓存。
public synchronized Entry get(String key) {}
根据 key 获取 Entry
1.获取缓存头部 CacheHeader entry = mEntries.get(key);
2.用计数流读取缓存头部
cis = new CountingInputStream(new BufferedInputStream(new FileInputStream(file)));
CacheHeader.readHeader(cis); // eat header
3.将流（除去缓存头部后的）转换为字节数组
byte[] data = streamToBytes(cis, (int) (file.length() - cis.bytesRead));
return entry.toCacheEntry(data);
public synchronized void initialize() {}
初始化 扫描缓存目录下所有的文件 将缓存头部读取出来 存放到集合中 显然，所有的缓存头部都是在内存中
1.File[] files = mRootDirectory.listFiles();
2.for (File file : files) {
3.fis = new BufferedInputStream(new FileInputStream(file));
CacheHeader entry = CacheHeader.readHeader(fis);
entry.size = file.length();
putEntry(entry.key, entry);
public synchronized void put(String key, Entry entry) {}
将缓存 Entry 放入集合
1.先检查缓存空间是否已满，已满则删除最近最少使用的缓存
pruneIfNeeded(entry.data.length);
看看这个方法 private void pruneIfNeeded(int neededSpace) {}
遍历 Entry 集合，拿到缓存头部，再拿到文件，删除文件 计算删除后大小 如此循环 和LruCache很像
之所以遍历，是因为 Entry 集合是 LinkedHashMap，最近使用的会放到链表的最后。
2.拿到 Entry 对应的文件，写缓存头部，再写缓存数据。
====================================================================================================
PoolingByteArrayOutputStream 类
在进行网络请求时，将网络响应实体转为 byte[] 数组时用到。
private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError {
PoolingByteArrayOutputStream bytes =
new PoolingByteArrayOutputStream(mPool, (int) entity.getContentLength());
byte[] buffer = null;
try {
InputStream in = entity.getContent();
if (in == null) {
throw new ServerError();
}
buffer = mPool.getBuf(1024);
int count;
while ((count = in.read(buffer)) != -1) {
bytes.write(buffer, 0, count);
}
return bytes.toByteArray();
} finally {
try {
// Close the InputStream and release the resources by "consuming the content".
entity.consumeContent();
} catch (IOException e) {
// This can happen if there was an exception above that left the entity in
// an invalid state.
VolleyLog.v("Error occured when calling consumingContent");
}
mPool.returnBuf(buffer);
bytes.close();
}
}
相比与 ByteArrayOutputStream 的优势是：
使用 PoolingByteArrayOutputStream 在向自身 byte[] 缓冲区写数据时，expand 获取的缓冲区是从 byte[] 池中获取
的，heap 的性能表现会更好。
ByteArrayOutputStream 向缓存区写数据时，会不断扩大自身缓存区，每次都是 new byte[]，查看源码就知道了。
private void expand(int i) {
/* Can the buffer handle @i more bytes, if not expand it */
if (count + i <= buf.length) {
return;
}
byte[] newbuf = mPool.getBuf((count + i) * 2);
System.arraycopy(buf, 0, newbuf, 0, count);
mPool.returnBuf(buf);
buf = newbuf;
}
这里同时也揭露了一个问题，Volley是将请求响应的实体放到了 byte[] 中，如果用 Volley 下载文件，问题可想而知。
====================================================================================================
