Android Volley 超时重试机制

喜欢ヅ旅行 2022-05-18 00:51 291阅读 0赞

前言：

Volley框架有许多优秀的机制，例如，HTTP缓存策略，内存和磁盘缓存策略，重试策略，四个网络线程一个缓存线程策略。

这里，从源码，解读Volley重试机制。

Volley中，定义出一个重试的RetryPolicy接口：

  1. /** * Retry policy for a request. * * 用途： * 1. 重试策略，一定时间，重新发起一个请求。 * 2. 获取当前时间，当前重试的请求个数 */
  2. public interface RetryPolicy { 
  4.     /** * 获取当前重试的时间. */
  5.     public int getCurrentTimeout();
  7.     /** * 返回当前重试次数 */
  8.     public int getCurrentRetryCount();
  9.     /** * 当应用超时的时候，准备下一次的重试 * @param error 上一次尝试发生的异常 * @throws VolleyError 当尝试不能执行，会抛出异常 */
  10.     public void retry(VolleyError error) throws VolleyError;
  11. }

接下来，看RetryPolicy接口的实现类DefaultRetryPolicy。

  1. /** * Default retry policy for requests. * 用途： * 请求中默认的重试策略 * 时间，重试次数，回退的乘数 */
  2. public class DefaultRetryPolicy implements RetryPolicy { 
  3.     /** 当前超时累计的时间（毫秒为单位） */
  4.     private int mCurrentTimeoutMs;
  6.     /** 当前重试次数 */
  7.     private int mCurrentRetryCount;
  9.     /** 最大重试次数 */
  10.     private final int mMaxNumRetries;
  12.     /** 超时的乘数因子 */
  13.     private final float mBackoffMultiplier;
  15.     /** 默认的重试一次的时间*/
  16.     public static final int DEFAULT_TIMEOUT_MS = 2500;
  18.     /** 默认的重试次数 */
  19.     public static final int DEFAULT_MAX_RETRIES = 1;
  21.     /** * 默认的超时的乘数因子 * * 当前的重试时间=上一次超时时间+(上一次的超时时间*乘数因子) * * 例如： 乘数因子为1 ，一次重试时间为2.5秒 ，最大的重试次数为2 * 第一次重试： 重试时间=2.5+2.5*1=5秒 * 第二次重试： 重试时间=5+5*1=10秒 * */
  22.     public static final float DEFAULT_BACKOFF_MULT = 1f;
  23.     /** * 使用默认的重试策略 */
  24.     public DefaultRetryPolicy() {
  25.         this(DEFAULT_TIMEOUT_MS, DEFAULT_MAX_RETRIES, DEFAULT_BACKOFF_MULT);
  26.     }
  27.     /** * * * 参数1：策略执行时间 * 参数2：在执行时间内，重试次数 * 参数3：回退的乘数。 当前时间+=（当前时间*参数3） * */
  28.     public DefaultRetryPolicy(int initialTimeoutMs, int maxNumRetries, float backoffMultiplier) {
  29.         mCurrentTimeoutMs = initialTimeoutMs;
  30.         mMaxNumRetries = maxNumRetries;
  31.         mBackoffMultiplier = backoffMultiplier;
  32.     }
  33.     /** * 返回当前重试的累加时间. */
  34.     @Override
  35.     public int getCurrentTimeout() {
  36.         return mCurrentTimeoutMs;
  37.     }
  39.     /** * 返回当前的重试次数，第几次重试 */
  40.     @Override
  41.     public int getCurrentRetryCount() {
  42.         return mCurrentRetryCount;
  43.     }
  44.     /** * 重试策略执行逻辑 */
  45.     @Override
  46.     public void retry(VolleyError error) throws VolleyError {
  47.         //累加尝试次数
  48.         mCurrentRetryCount++;
  49.         //累加重试时间
  50.         mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);
  51.         if (!hasAttemptRemaining()) {
  52.    //当前的重试次数大于指定重试次数，抛出该异常
  53.             throw error;
  54.         }
  55.     }
  56.     /** * 返回true ，则请求还有重试次数 */
  57.     protected boolean hasAttemptRemaining() {
  58.         return mCurrentRetryCount <= mMaxNumRetries;
  59.     }
  60. }

从以上代码可知： 重试时间=上次重试时间+上次重试时间*乘数因子。

设置了重试时间，但需要作用在Http请求上才有效。

接下来，看下重试策略如何作用在HttpUrlConnection的连接时间和响应时间。

找到HurlStack类，该类是执行HttpUrlConnection的逻辑操作类。

  1. public class HurlStack implements HttpStack { 
  3.      //...省略部分代码
  5.     /** * 根据url中带有的协议，来开启一个带有参数的HttpURLConnection，或者HttpsURLConnection */
  6.     private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
  7.         HttpURLConnection connection = createConnection(url);
  8.         //获取Request中的指定时间
  9.         int timeoutMs = request.getTimeoutMs();
  10.         //设置连接时间
  11.         connection.setConnectTimeout(timeoutMs);
  12.         //设置读取时间
  13.         connection.setReadTimeout(timeoutMs);
  14.         //...省略部分代码
  15.         return connection;
  16.     }
  18. }

可以发现设置的响应时间和连接时间都是Request中获取的。

接下来，找到Request类：

  1. public abstract class Request<T> implements Comparable<Request<T>> { 
  2.        public Request(int method, String url, Response.ErrorListener listener) {
  3.        //....省略部分代码
  4.         setRetryPolicy(new DefaultRetryPolicy());
  5.     }
  6.     /** * 设置重试策略 */
  7.     public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {
  8.         mRetryPolicy = retryPolicy;
  9.         return this;
  10.     }
  11.     /** * 重试策略中的当前累加重试时间 */
  12.     public final int getTimeoutMs() {
  13.         return mRetryPolicy.getCurrentTimeout();
  14.     }
  15. }

发现，Request这个超类已经默认设置了重试策略。

以上代码只是实现了重试机制的时间组作用在Http请求上，但如何计算重试机制的逻辑并没有实现，接下来查看Volley如何计算重试次数。

找到BasicNetwork 类：for循环方式，累加重试

  1. public class BasicNetwork implements Network { 
  2.       /** * 执行网络请求，返回响应数据 * * @param request Request to process * @return * @throws VolleyError 执行网络请求，for循环的方式，执行重试策略。 * <p> * 若是执行成功或者重试策略执行完抛出异常，跳出for循环。 */
  3.     @Override
  4.     public NetworkResponse performRequest(Request<?> request) throws VolleyError {
  5.         //引导后的毫秒数（包含睡眠花费的时间）
  6.         long requestStart = SystemClock.elapsedRealtime();
  7.         while (true) {
  8.                 //执行Http请求，每次循环都执行最新的重试时间
  9.                 mHttpStack.performRequest(request, headers);
  11.                 //若是服务器返回状态码在小于200或者待遇299时，抛出一个异常
  12.                 if (statusCode < 200 || statusCode > 299) {
  13.                     throw new IOException();
  14.                 }
  15.                 return new NetworkResponse(statusCode, responseContents, responseHeaders, false);
  16.             } catch (SocketTimeoutException e) {
  17.                //执行重试策略
  18.                 attemptRetryOnException("socket", request, new TimeoutError());
  19.             } catch (ConnectTimeoutException e) {
  20.                 //执行重试策略
  21.                 attemptRetryOnException("connection", request, new TimeoutError());
  22.             } catch (IOException e) {
  23.                 int statusCode = 0;
  24.                 NetworkResponse networkResponse = null;
  25.                 if (httpResponse != null) {
  26.                     statusCode = httpResponse.getStatusLine().getStatusCode();
  27.                 } else {
  28.                     throw new NoConnectionError(e);
  29.                 }
  30.                 VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
  31.                 if (responseContents != null) {
  32.                     networkResponse = new NetworkResponse(statusCode, responseContents, responseHeaders, false);
  33.                     if (statusCode == HttpStatus.SC_UNAUTHORIZED || statusCode == HttpStatus.SC_FORBIDDEN) {
  34.                           //执行重试策略 
  35.                           attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));
  36.                     } else {
  37.                         // TODO: Only throw ServerError for 5xx status codes.
  38.                         throw new ServerError(networkResponse);
  39.                     }
  40.                 } else {
  41.                     throw new NetworkError(networkResponse);
  42.                 }
  43.             }
  44.         }
  45.     }
  47.    /** * 执行，重试策略。 * <p> * 若是请求中已经没有更多的重试策略，抛出这次请求网络的异常。 * * @param request The request to use. */
  48.     private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError {
  49.         RetryPolicy retryPolicy = request.getRetryPolicy();
  50.         //上一次重试后的累计的时间
  51.         int oldTimeout = request.getTimeoutMs();
  52.         try {
  53.             retryPolicy.retry(exception);
  54.         } catch (VolleyError e) {
  55.             request.addMarker(String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
  56.             throw e;
  57.         }
  58.         request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
  59.     } 
  60. }

从以上代码可知： 每次执行Http请求都会捕捉SocketTimeoutException和ConnectTimeoutException和服务器验证的重试错误。当发生这几个异常的时候，会走attemptRetryOnException()，执行一次重试操作，并没有跳出for循环。当执行完网络请求会return跳出，或者重试策略执行完throw异常跳出。

成功执行完Request请求或者抛出异常，后并没有停止执行，而是传递结果到监听器中。

找到 NetworkDispatcher类：

  1. public class NetworkDispatcher extends Thread { 
  3.       @Override
  4.     public void run() {
  5.         //设置线程优先级，这里是后台线程
  6.         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  7.         Request<?> request;
  8.         //while循环，从网络队列中获取要执行的请求。
  9.         while (true) {
  10.             try {
  11.                 // 从网络队列中获取一个请求
  12.                 request = mQueue.take();
  13.             } catch (InterruptedException e) {
  14.               //当队列中抛出一个异常，且程序需要关闭网络线程池，则停止该线程。
  15.                 if (mQuit) {
  16.                     return;
  17.                 }
  18.                 continue;
  19.             }
  20.             try {
  21.                //....省略部分代码
  22.                 //在NetWork子类类中执行网络请求的操作，返回网络响应数据
  23.                 NetworkResponse networkResponse = mNetwork.performRequest(request);
  24.                 //....省略部分代码
  26.                 //在网络线程中指向解析响应的数据
  27.                 Response<?> response = request.parseNetworkResponse(networkResponse);
  29.                  //....省略部分代码
  30.                 //在ResponseDelivery类中回调请求和解析后响应数据
  31.                 mDelivery.postResponse(request, response);
  32.             } catch (VolleyError volleyError) {
  33.                 parseAndDeliverNetworkError(request, volleyError);
  34.             } catch (Exception e) {
  35.                 VolleyLog.e(e, "Unhandled exception %s", e.toString());
  36.                 mDelivery.postError(request, new VolleyError(e));
  37.             }
  38.         }
  39.     }
  40.     /** * 解析，传递网络异常。 * @param request * @param error */
  41.     private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
  42.         error = request.parseNetworkError(error);
  43.         mDelivery.postError(request, error);
  44.     }  
  45. }

BaseNetWork执行完Request重试策略后。抛出的异常会被 NetworkDispatcher线程中捕捉到，然后通过ResponseDelivery执行在主线程中回调给监听器。执行成功后服务器返回的Response数据会被解析，解析的结果通过通过ResponseDelivery执行在主线程中回调给监听器。

发表评论

表情：
评论列表 （有 0 条评论，291人围观）

还没有评论，来说两句吧...

相关阅读

    相关 超时与重试机制

    网上发现这篇好文章，这里记录学习。 介绍       在实际开发过程中，笔者见过太多故障是因为超时没有设置或者设置的不对而造成的。而这些故障都是因为没有意识到超时设置的

    ﹏ヽ暗。殇╰゛Y﹏ヽ暗。殇╰゛Y/ 0 赞/ 786 阅读