【深蓝】Volley 全程模拟

GET 

首先 要有一个RequestQueue 队列，实例化它。

 

    public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

最终需要的参数，第一个缓存，第二个网络请求，第三个网络线程的个数，第四个响应交付。

    /**
     * Starts the dispatchers in this queue.
     */
    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();

        // 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();
        }
    }

先直接开启这个线程，先stop 把现在所有的网络调度全部停止掉。

然后实例化一个缓存调度程序，几个networkDispatcher调度程序，调度程序其实就是一个Thread，然后开启他们。

而缓存需要的参数第一个为mCacheQueue缓存队列，先把请求添加到缓存队列，执行请求，如果没有结果，会添加到第二个队列mNetworkQueue网络队列，等待网络调度，

mCache也就是从这里找缓存，mDelivery 就是相当于结果回调。

网络调度程序 也有4个参数，分别为 网络请求低劣，执行的请求方法，缓存，当然还有回调。

 

public <T> Request<T> add(Request<T> request)

需要的参数为request

    /**
     * Creates a new request with the given method (one of the values from
     * {@link Method}), URL, and error listener. Note that the normal response
     * listener is not provided here as delivery of responses is provided by
     * subclasses, who have a better idea of how to deliver an already-parsed
     * response.
     */
    public Request(int method, String url, Response.ErrorListener listener) {
        mMethod = method;
        mUrl = url;
        mErrorListener = listener;
        setRetryPolicy(new DefaultRetryPolicy());

        mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);
    }

 

1：请求类型，GET POST之类的。Request.Method.GET XXX

2：请求的URL地址。

3：错误结果回调监听器。

4：失败的时候重试策略。

5：看了里面的构造为

    /**
     * @return The hashcode of the URL's host component, or 0 if there is none.
     */
    private static int findDefaultTrafficStatsTag(String url) {
        if (!TextUtils.isEmpty(url)) {
            Uri uri = Uri.parse(url);
            if (uri != null) {
                String host = uri.getHost();
                if (host != null) {
                    return host.hashCode();
                }
            }
        }
        return 0;
    }

　　如果Url 解析成Uri 然后返回Uri的HashCode

下面是add(Request )过程了。

request.setRequestQueue(this); 把request 关联到 请求队列中。

        synchronized (mCurrentRequests) {
            mCurrentRequests.add(request);
        }

mCurrentRequests就是一个HashSet 不能有重复的的请求。

request.setSequence(getSequenceNumber()); 获取一个请求序列号。自动增加的

if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}

如果请求不应该缓存，直接把请求添加到网络请求队列中。

 

        // Insert request into stage if there's already a request with the same cache key in flight.
        synchronized (mWaitingRequests) {
            String cacheKey = request.getCacheKey();
            if (mWaitingRequests.containsKey(cacheKey)) {
                // There is already a request in flight. Queue up.
                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);
                mCacheQueue.add(request);
            }
            return request;
        }

 

是否已经在请求队列中等等。

这个是应该缓存的，第一步先判断