Android中的volley_12_请求重试策略RetryPolicy和DefaultRetryPolicy

面相接口的编程思想已经深入到volley的骨髓中了，当学习完volley，就算没有别的收货，但面相接口的编程思想必定深深印在脑海中，从HttpStack、到Network、再到Request等都是利用的接口思想。今天所说的请求重试策略RetryPolicy依然遵循了此思想，不得不令人感叹！！！

其实，直到现在这一刻，才忽然意识到，似乎volley就是利用接口来搭建其骨架的，之前的时候知道volley内利用了大量的接口，但是自己也只是明白，但是没有什么直观的概念，对于volley源码的学习和研究已经有段时间了，对其各个部分，也有了直观的了解，现在想想在各个关键点用的都是接口，骨架使用接口搭建的，而volley也有一套默认的对这些接口的实现类，形成了骨架间的血肉。嘿嘿，跑远了。

请求重试策略，很高大上的样子，但其内部结构真的很简单，先看看最直观的源码：

/**
* Retry policy for a request.
* 请求的重新请求策略
*/
public interface RetryPolicy {

/**
* Returns the current timeout (used for logging).
* 获取当前请求用时（用于Log）
*/
public int getCurrentTimeout();

/**
* Returns the current retry count (used for logging).
* 已经重新请求了几次
*/
public int getCurrentRetryCount();

/**
* Prepares for the next retry by applying a backoff to the timeout.  确定是否重试，参数为这次异常的具体信息。在请求异常时此接口会被调用，可在此函数实现中抛出传入的异常表示停止重试。
* @param error The error code of the last attempt.
* @throws VolleyError In the event that the retry could not be performed (for example if we
* ran out of attempts), the passed in error is thrown.
*/
public void retry(VolleyError error) throws VolleyError;
}

接口就定义了三个方法：获取当前超时时间、获取重试次数和重试。前两个方法很直观，重要的是第三个方法public void retry(VolleyError error) throws VolleyError ，而对于第三个方法想要强调的是throws VolleyError 抛出异常，也就是说在retry内部会抛出异常，之前一个字面retry就认为是在该方法内部重新发出网络请求，其实不是这样的，在内部的真正操作是变更重试策略的属性，如超时时间和重试次数，当超过了重试策略设定的限定就会抛出异常。注意注意注意：retry并不是真正的去重新发出网络请求。请求的重试是在BasicNetwork内实现的。稍后会涉及到。

DefaultRetryPolicy，RetryPolicy的默认实现类，也是volley的默认的请求重试策略。

该类内部定义了重试策略的必备属性：

/** The current timeout in milliseconds. 当前超时时间*/
private int mCurrentTimeoutMs;

/** The current retry count. 当前重试次数*/
private int mCurrentRetryCount;

/** The maximum number of attempts. 最大重试次数*/
private final int mMaxNumRetries;

/** The backoff multiplier for for the policy. 表示每次重试之前的 timeout 该乘以的因子，每重试一次，超时时间就变化一次*/
private final float mBackoffMultiplier;

/** The default socket timeout in milliseconds 默认超时时间*/
public static final int DEFAULT_TIMEOUT_MS = 5000;

/** The default number of retries  默认最大重试次数*/
public static final int DEFAULT_MAX_RETRIES = 1;

DefaultRetryPolicy有两个构造方法，在创建实例时使用了默认的属性。

/**
* Constructs a new retry policy using the default timeouts.
* 构造时，使用了默认的几个参数
*/
public DefaultRetryPolicy() {
this(DEFAULT_TIMEOUT_MS, DEFAULT_MAX_RETRIES, DEFAULT_BACKOFF_MULT);
}

/**
* Constructs a new retry policy.
* @param initialTimeoutMs The initial timeout for the policy.  当前超时时间
* @param maxNumRetries The maximum number of retries.		最大重试次数
* @param backoffMultiplier Backoff multiplier for the policy.
*/
public DefaultRetryPolicy(int initialTimeoutMs, int maxNumRetries, float backoffMultiplier) {
mCurrentTimeoutMs = initialTimeoutMs;
mMaxNumRetries = maxNumRetries;
mBackoffMultiplier = backoffMultiplier;
}

再看另外两个方法：

/**
* Prepares for the next retry by applying a backoff to the timeout.
* @param error The error code of the last attempt.
*/
@Override
public void retry(VolleyError error) throws VolleyError {
//重试次数+1
mCurrentRetryCount++;
//超时时间每次都变化，增加
mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);
if (!hasAttemptRemaining()) {
//如果超过了最大重试次数就抛出异常
throw error;
}
}

/**
* Returns true if this policy has attempts remaining, false otherwise.
* 当前重试次数是否已经达到最大重试次数
*/
protected boolean hasAttemptRemaining() {
return mCurrentRetryCount <= mMaxNumRetries;
}

hasAttemptRemaining()方法返回的是，当前请求次数是否已经超过了最大的重试次数。retry()方法则是定义重试请求后属性的变化，如果超过了最大次数那么抛出异常。

到目前为止，好像除了规定了超时时间和重试次数，其他的跟请求重试也没什么关系。回顾下BasicNetwork内的方法：

/**
* 执行具体的网络请求 ，需要Volley的Request，返回的是可以被传递的响应
*/
@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
long requestStart = SystemClock.elapsedRealtime();
//这里使用while(true)的含义是：保证请求重试策略的执行。
//如果网络正常返回结果 那么直接return
//如果需要进行请求重试，就用到这里了，保证了可以进行请求重试
while (true) {
......
try {
...................
return new NetworkResponse(statusCode, responseContents, responseHeaders, false);
//如果发生超时，认证失败等错误，进行重试操作，直到成功、抛出异常(不满足重试策略等)结束
//当catch后没有执行上边的return  而当前又是一个while(true)循环，可以保证下面的请求重试的执行，是利用循环进行请求重试，请求重试策略只是记录重试的次数、超时 时间等内容。
} catch (SocketTimeoutException e) {
//当出现异常的时候，尝试进行请求重试
<span style="color:#ffcc66;"> </span><span style="background-color: rgb(255, 255, 102);">attemptRetryOnException("socket", request, new TimeoutError());</span>
} catch (ConnectTimeoutException e) {
//当出现异常的时候，尝试进行请求重试
<span style="background-color: rgb(255, 255, 102);"> attemptRetryOnException("connection", request, new TimeoutError());</span>
} catch (MalformedURLException e) {
//url不正常异常
throw new RuntimeException("Bad URL " + request.getUrl(), e);
} catch (IOException e) {
//当出现IO异常时，在try内读取数据体时，如果出现IO异常，那么捕获异常，继续完成创建NetworkResponse的过程
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) {
//请求重试策略
<span style="background-color: rgb(255, 255, 102);">attemptRetryOnException("auth",
request, new AuthFailureError(networkResponse));</span>
} else {
// TODO: Only throw ServerError for 5xx status codes.
throw new ServerError(networkResponse);
}
} else {
throw new NetworkError(networkResponse);
}
}
}
}

public NetworkResponse performRequest(Request<?> request)方法是执行网络请求的方法，那么理所当然的要进行请求重试也是在这里进行。如何进行请求重试，注意在方法的内部是用while(true)括起来的，也就是说如果该方法正常执行完毕或者抛出异常时，必然就跳出循环了，但是如果请求失败没有return并且在catch内也没有超过重试策略限定条件时，必然会while(true)下重新请求一次，这样就达到了重试的目的。

看一下attemptRetryOnException()方法内部：

/**
* 请求重试策略
* Attempts to prepare the request for a retry. If there are no more attempts remaining in the
* request's retry policy, a timeout exception is thrown.
* @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 {
//内部实现，重试次数+1  超时时间变化
//如果重试次数超过限定的最大次数，该方法抛出异常
retryPolicy.retry(exception);
} catch (VolleyError e) {
//当超过了最大重试次数，捕获到异常，给改请求添加标记 标记超时
request.addMarker(
String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
//这里才是最重要的，当仍然可以进行重试的时候，不会执行到catche语句，但是当执行到catch语句的时候，表示已经不能进行重试了，就抛出异常  这样while(true)循环就断了
throw e;
}
//给请求添加标记，请求了多少次
request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
}

其实到这里为止，文章已经可以结束了，但是在写文章的过程中又有了新的领悟，关于策略的。

百度了下关于策略的定义：

策略，指计策；谋略。一般是指：1. 可以实现目标的方案集合；2. 根据形势发展而制定的行动方针和斗争方法；3. 有斗争艺术，能注意方式方法。

应用到程序开发中，应该是理解为：可以实现目标的方案集合。需要注意的是，策略本身并不会具体的去执行。

DefaultRetryPolicy是请求重试的策略，它规定了超时时间、超时时间的变化、请求重试次数、最大请求重试次数以及请求重试后的变化，但是DefaultRetryPolicy并没有去执行真正的网络重试请求，仅仅是规划了，真正的重试还是要到网络请求类中。

写到这里，想到了volley中的Request，也应该算是一种策略，Request中定义了跟网络请求相关的必备属性，如请求方式、超时时间、参数等，但是Request并不会去执行网络请求，真正执行网络请求的还是BasicNetwork。

策略，是方案。

demo下载地址：http://download.csdn.net/detail/vvzhouruifeng/8747599