Android Volley 超时重试机制

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

前言：

> 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执行在主线程中回调给监听器。