前言：
Volley框架有许多优秀的机制，例如，HTTP缓存策略，内存和磁盘缓存策略，重试策略，四个网络线程一个缓存线程策略。
这里，从源码，解读Volley重试机制。
Volley中，定义出一个重试的RetryPolicy接口：
/**
* Retry policy for a request.
*
* 用途：
* 1. 重试策略，一定时间，重新发起一个请求。
* 2. 获取当前时间，当前重试的请求个数
*/
public interface RetryPolicy {
/**
* 获取当前重试的时间.
*/
public int getCurrentTimeout();
/**
* 返回当前重试次数
*/
public int getCurrentRetryCount();
/**
* 当应用超时的时候，准备下一次的重试
* @param error 上一次尝试发生的异常
* @throws VolleyError 当尝试不能执行，会抛出异常
*/
public void retry(VolleyError error) throws VolleyError;
}接下来，看RetryPolicy接口的实现类DefaultRetryPolicy。
/**
* Default retry policy for requests.
* 用途：
* 请求中默认的重试策略
* 时间，重试次数，回退的乘数
*/
public class DefaultRetryPolicy implements RetryPolicy {
/** 当前超时累计的时间（毫秒为单位） */
private int mCurrentTimeoutMs;
/** 当前重试次数 */
private int mCurrentRetryCount;
/** 最大重试次数 */
private final int mMaxNumRetries;
/** 超时的乘数因子 */
private final float mBackoffMultiplier;
/** 默认的重试一次的时间*/
public static final int DEFAULT_TIMEOUT_MS = 2500;
/** 默认的重试次数 */
public static final int DEFAULT_MAX_RETRIES = 1;
/**
* 默认的超时的乘数因子
*
* 当前的重试时间=上一次超时时间+(上一次的超时时间*乘数因子)
*
* 例如： 乘数因子为1 ，一次重试时间为2.5秒 ，最大的重试次数为2
* 第一次重试： 重试时间=2.5+2.5*1=5秒
* 第二次重试： 重试时间=5+5*1=10秒
* */
public static final float DEFAULT_BACKOFF_MULT = 1f;
/**
* 使用默认的重试策略
*/
public DefaultRetryPolicy() {
this(DEFAULT_TIMEOUT_MS, DEFAULT_MAX_RETRIES, DEFAULT_BACKOFF_MULT);
}
/**
*
*
* 参数1：策略执行时间
* 参数2：在执行时间内，重试次数
* 参数3：回退的乘数。 当前时间+=（当前时间*参数3）
*
*/
public DefaultRetryPolicy(int initialTimeoutMs, int maxNumRetries, float backoffMultiplier) {
mCurrentTimeoutMs = initialTimeoutMs;
mMaxNumRetries = maxNumRetries;
mBackoffMultiplier = backoffMultiplier;
}
/**
* 返回当前重试的累加时间.
*/
@Override
public int getCurrentTimeout() {
return mCurrentTimeoutMs;
}
/**
* 返回当前的重试次数，第几次重试
*/
@Override
public int getCurrentRetryCount() {
return mCurrentRetryCount;
}
/**
* 重试策略执行逻辑
*/
@Override
public void retry(VolleyError error) throws VolleyError {
//累加尝试次数
mCurrentRetryCount++;
//累加重试时间
mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);
if (!hasAttemptRemaining()) {//当前的重试次数大于指定重试次数，抛出该异常
throw error;
}
}
/**
* 返回true ，则请求还有重试次数
*/
protected boolean hasAttemptRemaining() {
return mCurrentRetryCount <= mMaxNumRetries;
}
}从以上代码可知： 重试时间=上次重试时间+上次重试时间*乘数因子。
设置了重试时间，但需要作用在Http请求上才有效。
接下来，看下重试策略如何作用在HttpUrlConnection的连接时间和响应时间。
找到HurlStack类，该类是执行HttpUrlConnection的逻辑操作类。
public class HurlStack implements HttpStack {
//...省略部分代码
/**
* 根据url中带有的协议，来开启一个带有参数的HttpURLConnection，或者HttpsURLConnection
*/
private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
HttpURLConnection connection = createConnection(url);
//获取Request中的指定时间
int timeoutMs = request.getTimeoutMs();
//设置连接时间
connection.setConnectTimeout(timeoutMs);
//设置读取时间
connection.setReadTimeout(timeoutMs);
//...省略部分代码
return connection;
}
}可以发现设置的响应时间和连接时间都是Request中获取的。
接下来，找到Request类：
public abstract class Request<T> implements Comparable<Request<T>> {
public Request(int method, String url, Response.ErrorListener listener) {
//....省略部分代码
setRetryPolicy(new DefaultRetryPolicy());
}
/**
* 设置重试策略
*/
public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {
mRetryPolicy = retryPolicy;
return this;
}
/**
* 重试策略中的当前累加重试时间
*/
public final int getTimeoutMs() {
return mRetryPolicy.getCurrentTimeout();
}
}发现，Request这个超类已经默认设置了重试策略。
以上代码只是实现了重试机制的时间组作用在Http请求上，但如何计算重试机制的逻辑并没有实现，接下来查看Volley如何计算重试次数。
找到BasicNetwork 类：for循环方式，累加重试
public class BasicNetwork implements Network {
/**
* 执行网络请求，返回响应数据
*
* @param request Request to process
* @return
* @throws VolleyError 执行网络请求，for循环的方式，执行重试策略。
* <p>
* 若是执行成功或者重试策略执行完抛出异常，跳出for循环。
*/
@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
//引导后的毫秒数（包含睡眠花费的时间）
long requestStart = SystemClock.elapsedRealtime();
while (true) {
//执行Http请求，每次循环都执行最新的重试时间
mHttpStack.performRequest(request, headers);
//若是服务器返回状态码在小于200或者待遇299时，抛出一个异常
if (statusCode < 200 || statusCode > 299) {
throw new IOException();
}
return new NetworkResponse(statusCode, responseContents, responseHeaders, false);
} catch (SocketTimeoutException e) {
//执行重试策略
attemptRetryOnException("socket", request, new TimeoutError());
} catch (ConnectTimeoutException e) {
//执行重试策略
attemptRetryOnException("connection", request, new TimeoutError());
} catch (IOException e) {
int statusCode = 0;
NetworkResponse networkResponse = null;
if (httpResponse != null) {
statusCode = httpResponse.getStatusLine().getStatusCode();
} else {
throw new NoConnectionError(e);
}
VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
if (responseContents != null) {
networkResponse = new NetworkResponse(statusCode, responseContents, responseHeaders, false);
if (statusCode == HttpStatus.SC_UNAUTHORIZED || statusCode == HttpStatus.SC_FORBIDDEN) {
//执行重试策略
attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));
} else {
// TODO: Only throw ServerError for 5xx status codes.
throw new ServerError(networkResponse);
}
} else {
throw new NetworkError(networkResponse);
}
}
}
}
/**
* 执行，重试策略。
* <p>
* 若是请求中已经没有更多的重试策略，抛出这次请求网络的异常。
*
* @param request The request to use.
*/
private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError {
RetryPolicy retryPolicy = request.getRetryPolicy();
//上一次重试后的累计的时间
int oldTimeout = request.getTimeoutMs();
try {
retryPolicy.retry(exception);
} catch (VolleyError e) {
request.addMarker(String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
throw e;
}
request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
}
}从以上代码可知： 每次执行Http请求都会捕捉SocketTimeoutException和ConnectTimeoutException和服务器验证的重试错误。当发生这几个异常的时候，会走attemptRetryOnException()，执行一次重试操作，并没有跳出for循环。当执行完网络请求会return跳出，或者重试策略执行完throw异常跳出。
成功执行完Request请求或者抛出异常，后并没有停止执行，而是传递结果到监听器中。
找到 NetworkDispatcher类：
public class NetworkDispatcher extends Thread {
@Override
public void run() {
//设置线程优先级，这里是后台线程
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Request<?> request;
//while循环，从网络队列中获取要执行的请求。
while (true) {
try {
// 从网络队列中获取一个请求
request = mQueue.take();
} catch (InterruptedException e) {
//当队列中抛出一个异常，且程序需要关闭网络线程池，则停止该线程。
if (mQuit) {
return;
}
continue;
}
try {
//....省略部分代码
//在NetWork子类类中执行网络请求的操作，返回网络响应数据
NetworkResponse networkResponse = mNetwork.performRequest(request);
//....省略部分代码
//在网络线程中指向解析响应的数据
Response<?> response = request.parseNetworkResponse(networkResponse);
//....省略部分代码
//在ResponseDelivery类中回调请求和解析后响应数据
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
}
}
}
/**
* 解析，传递网络异常。
* @param request
* @param error
*/
private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
error = request.parseNetworkError(error);
mDelivery.postError(request, error);
}
}BaseNetWork执行完Request重试策略后。抛出的异常会被 NetworkDispatcher线程中捕捉到，然后通过ResponseDelivery执行在主线程中回调给监听器。执行成功后服务器返回的Response数据会被解析，解析的结果通过通过ResponseDelivery执行在主线程中回调给监听器。