Android 学习笔记之Volley开源框架解析（二）

package com.android.volley;

/**
 * Retry policy for a request.
 */
public interface RetryPolicy {

    /**
     * Returns the current timeout (used for logging).
     */
    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;
}

 /** 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. */
    private final float mBackoffMultiplier; //一个乘数因子，每次超时时间的获取都需要乘上这个乘数因子...

    /** The default socket timeout in milliseconds */
    public static final int DEFAULT_TIMEOUT_MS = 2500;//定义默认的超时时间...

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

    /** The default backoff multiplier */
    public static final float DEFAULT_BACKOFF_MULT = 1f;//默认的乘数因子的定义..

public DefaultRetryPolicy() {
        this(DEFAULT_TIMEOUT_MS, DEFAULT_MAX_RETRIES, DEFAULT_BACKOFF_MULT);
}

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

    /**
     * Returns true if this policy has attempts remaining, false otherwise.
     */
    protected boolean hasAttemptRemaining() {
        return mCurrentRetryCount <= mMaxNumRetries;
    }

 /** Used for generating monotonically-increasing sequence numbers for requests. */
    private AtomicInteger mSequenceGenerator = new AtomicInteger();//自动生成序列号...

    private final Map<String, Queue<Request>> mWaitingRequests =
            new HashMap<String, Queue<Request>>();  //如果一个请求可以被缓存并且正在被执行，那么后续与之相同的url请求进入此队列...

    private final Set<Request> mCurrentRequests = new HashSet<Request>(); //用于保存尚未完成请求的集合...

    private final PriorityBlockingQueue<Request> mCacheQueue =
        new PriorityBlockingQueue<Request>(); //用于保存缓存请求，从缓存中取出数据...

    private final PriorityBlockingQueue<Request> mNetworkQueue =
        new PriorityBlockingQueue<Request>(); //用于保存网络请求，从服务器上获取数据...

    /** Number of network request dispatcher threads to start. */
    private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4; //默认的网络线程数量...

    /** Cache interface for retrieving and storing respones. */
    private final Cache mCache;  //缓存机制...用于保存缓存数据...

    /** Network interface for performing requests. */
    private final Network mNetwork; //用于执行网络请求...

    /** Response delivery mechanism. */
    private final ResponseDelivery mDelivery; //用于分发相应..

    /** The network dispatchers. */
    private NetworkDispatcher[] mDispatchers; //网络调度线程...

    /** The cache dispatcher. */
    private CacheDispatcher mCacheDispatcher; //缓存调度线程...

public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
}
 public RequestQueue(Cache cache, Network network, int threadPoolSize) {
        this(cache, network, threadPoolSize,
                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
 public RequestQueue(Cache cache, Network network) {
        this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
}

RequestQueue queue=Volley.newRequestQueue(MainActivity.this);

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(); //调用start()方法开启线程..

        // Create network dispatchers (and corresponding threads) up to the pool size.
        for (int i = 0; i < mDispatchers.length; i++) {
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                    mCache, mDelivery);  //根据指定大小，实例化网络请求对象...
            mDispatchers[i] = networkDispatcher; //赋值
            networkDispatcher.start(); //开启网络线程..
        }
    }

  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设置请求队列...
        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;
        }

        //如果请求允许被缓存...首先判断是否有同样的缓存请求在这个队列当中...
        synchronized (mWaitingRequests) {
            String cacheKey = request.getCacheKey();
            if (mWaitingRequests.containsKey(cacheKey)) {
                 //如果请求队列中有正在处理与之相同的请求，那么直接将其加入相同请求的等待队列当中...
                Queue<Request> stagedRequests = mWaitingRequests.get(cacheKey);
                if (stagedRequests == null) {
                    stagedRequests = new LinkedList<Request>();
                }
                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);//这里传递空值，当再次回调这个函数的时候，就会调用if中的函数，从而完成队列的创建...
                mCacheQueue.add(request);
            }
            return request;
        }
    }

  void finish(Request request) {
        // Remove from the set of requests currently being processed.
        synchronized (mCurrentRequests) {
            mCurrentRequests.remove(request); //从当前请求队列中移出..
        }

        if (request.shouldCache()) { //判断是否允许缓存...
            synchronized (mWaitingRequests) {
                String cacheKey = request.getCacheKey();
                Queue<Request> waitingRequests = mWaitingRequests.remove(cacheKey); //获取所有相同的请求...
                if (waitingRequests != null) {
                    if (VolleyLog.DEBUG) {
                        VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",
                                waitingRequests.size(), cacheKey);
                    }
                    // Process all queued up requests. They won‘t be considered as in flight, but
                    // that‘s not a problem as the cache has been primed by ‘request‘.
                    mCacheQueue.addAll(waitingRequests); //将所有的请求放入到缓存队列当中,由缓存队列完成请求响应...
                }
            }
        }
    }

public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }

public int getSequenceNumber() {
        return mSequenceGenerator.incrementAndGet();
}

 public Cache getCache() {
        return mCache;
 }