Volley源码解析

源码下载地址：https://github.com/code-study/android-volley-analysis

一、原理

Volley有两个调度器，缓存请求调度器和网络请求调度器，两个调度器均是Thread的子类，且拥有各自的队列；初始化Volley时启动两个线程，在子线程中while（ture）循环，将请求加入队列，通过队列阻塞的方式，控制请求流程。

二、源码分析

1、使用方式

RequestQueue requestQueue = Volley.newRequestQueue(this);

StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener() {
  @Override
  public void onResponse(String response) {
  }
  }, new Response.ErrorListener() {
  @Override
  public void onErrorResponse(VolleyError error) {
}
});
requestQueue.add(request);

2、流程分析

（1）Volley.java

首先创建RequestQueue的实例；创建网络请求，再将其封装；创建缓存机制并设置缓存目录；

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) { // context.getCacheDir() : /data/data/com.android.volley.test/cache 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 : com.android.volley.test/1
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}

//创建网络请求
if (stack == null) {
//在 Froyo(2.2) 之前，HttpURLConnection 有个重大 Bug，调用 close() 函数会影响连接池，导致连接复用失效，所以在2.2之前使用        HttpURLConnection 需要关闭 keepAlive。
// Gingerbread(2.3) HttpURLConnection 默认开启了 gzip 压缩，提高了 HTTPS 的性能，Ice Cream Sandwich(4.0)     HttpURLConnection 支持了请求结果缓存
if (Build.VERSION.SDK_INT >= 9) {
//HttpURLConnection
stack = new HurlStack();
} else {
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
//HttpClient
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;
}

****详细分析：** 首先设置缓存文件地址，用于缓存请求回来的结果。创建网络请求，若android版本大于等于9的话，则使用HurlStack（实际是HttpURLConnection），否则使用HttpClientStack（实际是HttpClient），原因是在 Froyo(2.2) 之前，HttpURLConnection 有个重大 Bug，调用 close() 函数会影响连接池，导致连接复用失效，所以在2.2之前使用 HttpURLConnection 需要关闭 keepAlive。Gingerbread(2.3) HttpURLConnection 默认开启了 gzip 压缩，提高了 HTTPS 的性能，Ice Cream Sandwich(4.0) HttpURLConnection 支持了请求结果缓存。将网络请求封装到BasicNetWork，用于真正执行请求，后面将会详细说明。创建RequestQueue并start，可以设置最大缓存bytes（maxDiskCacheBytes），默认是5M。

（2）RequestQueue.java

Volley的核心是调度线程，首先终止所有的调度线程，即调用所有调度器的interrupt（调度器均为Thread）；启用一个缓存线程，和四个网络线程；两种调度线程run方法均开启while(true)循环，通过队列阻塞方式控制请求流程，下面会详情说明。

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.
// 网络请求调度器,默认开启DEFAULT_NETWORK_THREAD_POOL_SIZE(4)个线程，相当于线程池
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork, mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}

接下来调用RequestQueue的add方法，将请求加入队列；如果不需要缓存则加入网络队列，否则加入缓存队列，相应的调度线程获取队列元素解除阻塞，会往下执行相应的逻辑。加入缓存队列之前需要先判断是否有相同的请求在执行中，若有则加入等待队列，待前一次请求执行完之后，再执行。

public  Request add(Request request) {
// Tag the request as belonging to this queue and add it to the set of current requests.
request.setRequestQueue(this); //为Request设置请求队列

//将请求add到当前请求队列中
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> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList>();
}
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;
}
}

****详细分析：** 有两个队列需要说明一下，mCurrentRequests正在被请求的队列，在调用上述add的时候，需将当前请求加入到此队列，主要作用是取消请求；另一个是mWaitingRequests，作用是避免多次发送相同请求，若当前没有相同请求正在处理，则将当前请求key中加入空队列；当请求结束时，移除mWaitingRequests中的当前请求key中的等待请求，并将当前key中的所有等待请求加入到缓存队列（可见RequestQueue中的finish）。

（3）NetworkDispatcher和CacheDispatcher

上面说到请求加入队列后会有相应的调度线程来处理，这也是Volley中最重要的部分

NetworkDispatcher.java 先看一下网络调度线程；在run中执行while(true)，若网络队列中没有元素则阻塞队列，直到队列有元素加入，取出元素request，通过网络请求，将返回的response加入缓存（若需缓存）且将结果分发给上层回调。

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");

// 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) {
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);
}
}
}

CacheDispatcher.java 接下来看一下缓存调度线程；在run中执行while(true)，若缓存队列中没有元素则阻塞队列，直到队列有元素加入，取出元素request，通过key取出缓存，若缓存无数据或者已过期则加入网络队列进行网络请求，否则取出缓存封装成response；若缓存不需要更新则直接分发给上层回调，否则再次提交网络请求。

@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());

//缓存已过期（包括expired与Soft-expired）

// 无缓存数据，则加入网络请求
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.
// 缓存没有Soft-expired，则直接通过mDelivery将解析好的结果交付给请求发起者
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());
}
}
}

（4）BasicNetwork.java

封装HttpStack网络请求，实际由HttpStack实现。

@Override
public NetworkResponse performRequest(Request request) throws VolleyError {
//获取请求开始的时间 debug用的
long requestStart = SystemClock.elapsedRealtime();

//如果发生超时，认证失败等错误，进行重试操作，直到成功、抛出异常(不满足重试策略等)结束
while (true) {
HttpResponse httpResponse = null;

//请求内容对象
byte[] responseContents = null;
//用于保存响应数据报的Header中的数据
Map responseHeaders = Collections.emptyMap();

try {
// Gather headers. 保存缓存下来的Header
Map headers = new HashMap();
// 添加请求头部的过程
addCacheHeaders(headers, request.getCacheEntry());
// 执行请求
httpResponse = mHttpStack.performRequest(request, headers);

//获取响应状态
StatusLine statusLine = httpResponse.getStatusLine();
//响应状态码
int statusCode = statusLine.getStatusCode();
//获取响应后的Header中的所有数据
responseHeaders = convertHeaders(httpResponse.getAllHeaders());

// Handle cache validation.
// 304:表示从上次访问后，服务器数据没有改变，则从Cache中拿数据
if (statusCode == HttpStatus.SC_NOT_MODIFIED) {

Entry entry = request.getCacheEntry();
if (entry == null) {
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null, responseHeaders, true,   SystemClock.elapsedRealtime() - requestStart);
}

// A HTTP 304 response does not have all header fields. We
// have to use the header fields from the cache entry plus
// the new ones from the response.
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
entry.responseHeaders.putAll(responseHeaders);
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data, entry.responseHeaders, true,     SystemClock.elapsedRealtime() - requestStart);
}

// Handle moved resources
if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
String newUrl = responseHeaders.get("Location");
request.setRedirectUrl(newUrl);
}

// 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.
//由于204响应时不返回数据信息的,返回空数据
responseContents = new byte[0];
}

// if the request is slow, log it.
long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
//如果一个请求的时间超过了指定的缓慢请求时间，那么需要显示这个时间,debug
logSlowRequests(requestLifetime, request, responseContents, statusLine);

//如果请求状态出现错误,bug
//if (statusCode != HttpStatus.SC_OK && statusCode != HttpStatus.SC_NO_CONTENT) {
if (statusCode < 200 || statusCode > 299) {
throw new IOException();
}

// 返回header+body数据
return new NetworkResponse(statusCode, responseContents, responseHeaders, false, SystemClock.elapsedRealtime() - requestStart);

} catch (SocketTimeoutException e) {
attemptRetryOnException("socket", request, new TimeoutError());
} catch (ConnectTimeoutException e) {
attemptRetryOnException("connection", request, new TimeoutError());
} catch (MalformedURLException e) {
throw new RuntimeException("Bad URL " + request.getUrl(), e);
} catch (IOException e) {
int statusCode = 0;
NetworkResponse networkResponse = null;

if (httpResponse != null) {
statusCode = httpResponse.getStatusLine().getStatusCode();

} else {
throw new NoConnectionError(e);
}

if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
VolleyLog.e("Request at %s has been redirected to %s", request.getOriginUrl(), request.getUrl());
} else {
VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
}

if (responseContents != null) {
networkResponse = new NetworkResponse(statusCode, responseContents, responseHeaders, false,     SystemClock.elapsedRealtime() - requestStart);

//请求需要进行验证，或者是需要授权异常处理
if (statusCode == HttpStatus.SC_UNAUTHORIZED || statusCode == HttpStatus.SC_FORBIDDEN) {
//尝试重试策略方法
attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));

} else if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
attemptRetryOnException("redirect", request, new RedirectError(networkResponse));

} else {
// TODO: Only throw ServerError for 5xx status codes.
throw new ServerError(networkResponse);

}

} else {
throw new NetworkError(e);
}
}
}
}

****详细分析：** 在网络分发器中用到了这里，主要通过这个方法来获取请求结果。此方法中也有个while(true)循环，如果发生超时，认证失败等错误，进行重试操作，直到成功、抛出异常(不满足重试策略等)结束；实际由HttpStack执行请求，将请求结果封装到NetworkResponse中（之后通过Request子类将其转成需要的类型分发给上层回调）。

（5）HttpClientStack和HurlStack

在上述调度线程中，实际处理请求获取到请求的结果的类就是这两个，这两个类同implements了HttpStack接口，这个接口只有一个方法需要实现，performRequest处理请求。

HurlStack.java performRequest内由HttpURLConnection处理网络请求，返回response

@Override
public HttpResponse performRequest(Request request, Map additionalHeaders)

throws IOException, AuthFailureError { String url = request.getUrl();

//添加head:请求head+额外的head
HashMap map = new HashMap();
map.putAll(request.getHeaders());
map.putAll(additionalHeaders);

//目前没有使用到,对url进行重写，重写的好处使url更加的保密，安全
if (mUrlRewriter != null) {
String rewritten = mUrlRewriter.rewriteUrl(url);
if (rewritten == null) {
throw new IOException("URL blocked by rewriter: " + url);
}
url = rewritten;
}

URL parsedUrl = new URL(url);
// 建立连接
HttpURLConnection connection = openConnection(parsedUrl, request);
// 设置请求的相关属性
for (String headerName : map.keySet()) {
connection.addRequestProperty(headerName, map.get(headerName));
}

//请求的方式去执行相关的方法
setConnectionParametersForRequest(connection, request);

// Initialize HttpResponse with data from the HttpURLConnection.
//获取协议版本
ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);

//响应码
int responseCode = connection.getResponseCode();

// 有的接口返回401，connection.getResponseCode(responseCode＝401)就会抛出IOException
// 解决方案 : http://blog.csdn.net/kufeiyun/article/details/44646145
// http://stackoverflow.com/questions/30476584/android-volley-strange-error-with-http-code-401-java-io-  ioexception-no-authe

if (responseCode == -1) {
// -1 is returned by getResponseCode() if the response code could not be retrieved.
// Signal to the caller that something was wrong with the connection.
throw new IOException("Could not retrieve response code from HttpUrlConnection.");
}

//响应信息
StatusLine responseStatus = new BasicStatusLine(protocolVersion, connection.getResponseCode(),     connection.getResponseMessage());
//响应状态
BasicHttpResponse response = new BasicHttpResponse(responseStatus);

//获取响应中的实体
if (hasResponseBody(request.getMethod(), responseStatus.getStatusCode())) {
response.setEntity(entityFromConnection(connection));
}

for (Entry> header : connection.getHeaderFields().entrySet()) {
if (header.getKey() != null) {
Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
response.addHeader(h);
}
}
return response;
}

HttpClientStack performRequest内由HttpClient处理网络请求，返回response

@Override
public HttpResponse performRequest(Request request, Map additionalHeaders) throws IOException,     AuthFailureError {
//创建请求
HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);

//添加head
addHeaders(httpRequest, additionalHeaders);
addHeaders(httpRequest, request.getHeaders());

//准备请求回调
onPrepareRequest(httpRequest);

HttpParams httpParams = httpRequest.getParams();
int timeoutMs = request.getTimeoutMs();
// TODO: Reevaluate this connection timeout based on more wide-scale
// data collection and possibly different for wifi vs. 3G.
// 设置连接超时时间5S
HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
// 设置请求超时,默认设置2.5s
HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
// 执行
return mClient.execute(httpRequest);
}

（6）ResponseDelivery和ExecutorDelivery

在调度线程中获取到结果后，当然就需要分发结果返回给上层回调处理，分发器就是ExecutorDelivery，其中ResponseDelivery是ExecutorDelivery需要实现的接口，此接口中只包含请求成功和失败的处理方法。在ExecutorDelivery中使用了线程池的管理，不用每次创建新的线程，重复使用已有线程即可，节省内存。

public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
//传入的Handler与主线程绑定了，所以分发消息是在主线程中
handler.post(command);
}
};
}

在主线程的runnable中分发网络请求结果给listener 将网络请求的结果返回给上层回调；若有附加线程则启动，主要在缓存调度器中使用，若需要刷新请求则在附件线程中重新执行网络请求。

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();
}
}
}

（7）Request

接下来看一下我们一直提到的Request，Volley中Request的子类：ClearCacheRequest、JsonRequest、JsonArrayRequest、JsonObjectRequest、ImageRequest、StringRequest 由于调度队列中的请求队列和网络队列都是优先级队列，其中的元素就是Request，故Request实现了Comparable接口，即需要实现compareTo，此方法主要作用是排列请求的优先级：优先级越高越前、优先级相同则根据序号来排、序号越低越前。 Request中有两个方法需要子类实现。parseNetworkResponse(NetworkResponse response)：将原始的请求结果封装成所需要的数据类型；deliverResponse：将请求结果分发给上层回调处理。各子类的实现较为简单，就不做详细说明了。

@Override
public int compareTo(Request other) {
Priority left = this.getPriority();
Priority right = other.getPriority();

//优先级越高，在请求队列中排得越前，相同优先级的序号越低，排得越前。
// High-priority requests are "lesser" so they are sorted to the front.
// Equal priorities are sorted by sequence number to provide FIFO ordering.
return left == right ?
this.mSequence - other.mSequence :
right.ordinal() - left.ordinal();

//ordinal():回此枚举常量的序数,从0开始，下标
}