主目錄見(jiàn)：Android高級(jí)進(jìn)階知識(shí)（這是總目錄索引）
?這是我們第一篇講解網(wǎng)絡(luò)請(qǐng)求相關(guān)的框架，前面我們的所有講解都是跟網(wǎng)絡(luò)請(qǐng)求沒(méi)有關(guān)系，如果大家對(duì)Http協(xié)議的原理等還不熟悉，希望大家自己復(fù)習(xí)一下，畢竟還是要知其然知其所以然，首先為了大家對(duì)[Volley]有個(gè)整體的認(rèn)識(shí)，我們先貼個(gè)圖：

Volley原理圖

一.目標(biāo)

?今天我們是講解網(wǎng)絡(luò)請(qǐng)求框架的第一篇，希望大家有個(gè)好的開(kāi)始，接下來(lái)有時(shí)間會(huì)相應(yīng)地講解OkHttp和retrofit的源碼，敬請(qǐng)期待，今天目標(biāo)如下：
1.從源碼角度深刻了解Volley的源碼;
2.知道怎么自定義Request。

二.源碼解析

我們分析源碼從最基礎(chǔ)的用法入手，我們回顧下Volley的最基本用法，這里以StringRequest為例：
1.創(chuàng)建一個(gè)RequestQueue對(duì)象

RequestQueue mQueue = Volley.newRequestQueue(context);  

2.創(chuàng)建一個(gè)StringRequest對(duì)象

StringRequest stringRequest = new StringRequest("http://www.baidu.com",  
                        new Response.Listener<String>() {  
                            @Override  
                            public void onResponse(String response) {  
                                Log.d("TAG", response);  
                            }  
                        }, new Response.ErrorListener() {  
                            @Override  
                            public void onErrorResponse(VolleyError error) {  
                                Log.e("TAG", error.getMessage(), error);  
                            }  
                        });  

3.將StringRequest對(duì)象添加到RequestQueue里面。

mQueue.add(stringRequest);  

這樣三步，最基本的使用就已經(jīng)完成了，那么我們現(xiàn)在遵循這個(gè)步驟來(lái)進(jìn)行源碼解析。

1.Volley newRequestQueue

首先我們看到Volley這個(gè)類(lèi)里面的這個(gè)方法：

public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, (BaseHttpStack) null);
    }

我們看到這個(gè)方法調(diào)用了兩個(gè)參數(shù)的同個(gè)方法，第二個(gè)參數(shù)傳的是null，我們就來(lái)看看兩個(gè)參數(shù)的這個(gè)方法：

 public static RequestQueue newRequestQueue(Context context, BaseHttpStack stack) {
        BasicNetwork network;
        if (stack == null) {
//這個(gè)方法是public的，以為這我們可以自己傳一個(gè)stack進(jìn)來(lái)，如果我們沒(méi)有傳進(jìn)來(lái)則需要進(jìn)行下面的操作
            if (Build.VERSION.SDK_INT >= 9) {
                network = new BasicNetwork(new HurlStack());
            } else {
                // Prior to Gingerbread, HttpUrlConnection was unreliable.
                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
                // At some point in the future we'll move our minSdkVersion past Froyo and can
                // delete this fallback (along with all Apache HTTP code).
                String userAgent = "volley/0";
                try {
                    String packageName = context.getPackageName();
                    PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
                    userAgent = packageName + "/" + info.versionCode;
                } catch (NameNotFoundException e) {
                }

                network = new BasicNetwork(
                        new HttpClientStack(AndroidHttpClient.newInstance(userAgent)));
            }
        } else {
//如果有傳stack這個(gè)參數(shù)我們就使用他構(gòu)造一個(gè)BasicNetwork對(duì)象
            network = new BasicNetwork(stack);
        }

        return newRequestQueue(context, network);
    }

我們看到我們這里會(huì)進(jìn)行版本的判斷，如果android的版本大于等于9則使用HurlStack作為BasicNetwork的參數(shù)，如果小于9呢則讓HttpClientStack作為BasicNetwork作為參數(shù)，其中HurlStack用的是HttpURLConnection訪問(wèn)的網(wǎng)絡(luò)，HttpClientStack使用HttpClient問(wèn)網(wǎng)絡(luò)。最后又調(diào)用了另外一個(gè)newRequestQueue方法，我們一起來(lái)看看：

  private static RequestQueue newRequestQueue(Context context, Network network) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();
        return queue;
    }

我們看到這里得到一個(gè)File對(duì)象，這個(gè)File對(duì)象主要是指定緩存的目錄，然后傳給DiskBasedCache這個(gè)緩存類(lèi)的（public class DiskBasedCache implements Cache），記住這個(gè)類(lèi)，后面從緩存中取出數(shù)據(jù)和放入數(shù)據(jù)都是放的這里面。然后將這個(gè)緩存類(lèi)和BasicNetwork傳給RequestQueue來(lái)構(gòu)建這個(gè)對(duì)象。我們看下RequestQueue這個(gè)對(duì)象是怎么構(gòu)建的：

  public RequestQueue(Cache cache, Network network) {
        this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
    }

DEFAULT_NETWORK_THREAD_POOL_SIZE這里的值默認(rèn)是4，我們看到這邊又調(diào)用了RequestQueue的三個(gè)參數(shù)的構(gòu)造函數(shù)：

public RequestQueue(Cache cache, Network network, int threadPoolSize) {
        this(cache, network, threadPoolSize,
                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
    }

我們看到這里又出現(xiàn)了一個(gè)新的類(lèi)ExecutorDelivery，這個(gè)類(lèi)里面?zhèn)鬟M(jìn)了一個(gè)在主線中的Handler,其實(shí)這個(gè)類(lèi)就是后面負(fù)責(zé)用來(lái)把解析完的網(wǎng)絡(luò)的結(jié)果返回給主線程的。同樣，這個(gè)類(lèi)又調(diào)用了四個(gè)參數(shù)的構(gòu)造函數(shù)：

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

我們看到了這里面就是將緩存類(lèi)DiskBasedCache，網(wǎng)絡(luò)訪問(wèn)類(lèi)BasicNetWork，還有利用threadPoolSize=4創(chuàng)建一個(gè)NetworkDispatcher數(shù)組，發(fā)送到主線程類(lèi)ExecutorDelivery賦值給RequestQueue的變量中，后面都會(huì)用到，望大家注意！！！！

2.RequestQueue start

我們看到在獲取到RequestQueue對(duì)象完之后會(huì)調(diào)用RequestQueue的start()方法：

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

我們看到程序會(huì)new出一個(gè)CacheDispatcher對(duì)象，然后調(diào)用它的start()方法，CacheDispatcher是一個(gè)Thread子類(lèi)，就是上面圖片說(shuō)的這是個(gè)緩存調(diào)度線程。然后我們看到會(huì)遍歷mDispatchers數(shù)組，這就是我們剛才用threadPoolSize=4創(chuàng)建的，我們這里遍歷創(chuàng)建四個(gè)NetworkDispatcher 對(duì)象，然后調(diào)用start()方法，同樣的NetworkDispatcher同時(shí)也是一個(gè)Thread的子類(lèi)，這就是前面圖片說(shuō)的網(wǎng)絡(luò)調(diào)度線程。然后我們根據(jù)基本用法知道我們這時(shí)候還需要一個(gè)StringRequest請(qǐng)求對(duì)象。我們看下這個(gè)到底是什么。

3.StringRequest

這個(gè)類(lèi)其實(shí)是繼承Request的類(lèi)：

public class StringRequest extends Request<String> {

    /** Lock to guard mListener as it is cleared on cancel() and read on delivery. */
    private final Object mLock = new Object();

    // @GuardedBy("mLock")
    private Listener<String> mListener;

    /**
     * Creates a new request with the given method.
     *
     * @param method the request {@link Method} to use
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public StringRequest(int method, String url, Listener<String> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    /**
     * Creates a new GET request.
     *
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }

    @Override
    public void cancel() {
        super.cancel();
        synchronized (mLock) {
            mListener = null;
        }
    }

    @Override
    protected void deliverResponse(String response) {
        Response.Listener<String> listener;
        synchronized (mLock) {
            listener = mListener;
        }
        if (listener != null) {
            listener.onResponse(response);
        }
    }

    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }
}

首先StringRequest是繼承自Request類(lèi)的，Request可以指定一個(gè)泛型類(lèi)，這里指定的當(dāng)然就是String了，接下來(lái)StringRequest中提供了兩個(gè)有參的構(gòu)造函數(shù)，參數(shù)包括請(qǐng)求類(lèi)型，請(qǐng)求地址，以及響應(yīng)回調(diào)等。但需要注意的是，在構(gòu)造函數(shù)中一定要調(diào)用super()方法將這幾個(gè)參數(shù)傳給父類(lèi)，因?yàn)镠TTP的請(qǐng)求和響應(yīng)都是在父類(lèi)中自動(dòng)處理的。

另外，由于Request類(lèi)中的deliverResponse()和parseNetworkResponse()是兩個(gè)抽象方法，因此StringRequest中需要對(duì)這兩個(gè)方法進(jìn)行實(shí)現(xiàn)。deliverResponse()方法中的實(shí)現(xiàn)很簡(jiǎn)單，僅僅是調(diào)用了mListener中的onResponse()方法，并將response內(nèi)容傳入即可，這樣就可以將服務(wù)器響應(yīng)的數(shù)據(jù)進(jìn)行回調(diào)了。parseNetworkResponse()方法中則應(yīng)該對(duì)服務(wù)器響應(yīng)的數(shù)據(jù)進(jìn)行解析，其中數(shù)據(jù)是以字節(jié)的形式存放在NetworkResponse的data變量中的，這里將數(shù)據(jù)取出然后組裝成一個(gè)String，并傳入Response的success()方法中即可。

4.RequestQueue add

得到RequestQueue 的對(duì)象以及Request對(duì)象之后，我們需要將這個(gè)Request對(duì)象添加進(jìn)這個(gè)Queue里面去。我們看看這個(gè)add做了什么：

 public <T> Request<T> add(Request<T> request) {
        // Tag the request as belonging to this queue and add it to the set of current requests.
        request.setRequestQueue(this);
        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;
        }
        mCacheQueue.add(request);
        return request;
     }

我們看到首先將request對(duì)象添加進(jìn)mCurrentRequests里面，記錄當(dāng)前的request請(qǐng)求。然后我們看到會(huì)判斷shouldCache()是否返回要緩存，一般情況下是true的，但是我們可以自己修改，調(diào)用setShouldCache()來(lái)改變這個(gè)值。如果要緩存則直接調(diào)用mCacheQueue#add()方法將這個(gè)request添加進(jìn)緩存隊(duì)列中。如果不需要緩存則直接添加進(jìn)網(wǎng)絡(luò)請(qǐng)求隊(duì)列中去。

5.CacheDispatcher run

我們知道前面將request將請(qǐng)求添加進(jìn)隊(duì)列里面，那么網(wǎng)絡(luò)請(qǐng)求線程和緩存請(qǐng)求線程的run方法肯定會(huì)從隊(duì)列里面取出任務(wù)來(lái)執(zhí)行，我們先來(lái)看下緩存請(qǐng)求線程做了什么工作：

    @Override
    public void run() {
        if (DEBUG) VolleyLog.v("start new dispatcher");
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

        // Make a blocking call to initialize the cache.
        mCache.initialize();

        while (true) {
            try {
                // Get a request from the cache triage queue, blocking until
                // at least one is available.
//首先從緩存隊(duì)列中取出任務(wù)
                final Request<?> request = mCacheQueue.take();
                request.addMarker("cache-queue-take");

                // If the request has been canceled, don't bother dispatching it.
                if (request.isCanceled()) {
//判斷這個(gè)request是不是已經(jīng)取消了，取消了就直接結(jié)束即可
                    request.finish("cache-discard-canceled");
                    continue;
                }

                // Attempt to retrieve this item from cache.
//從緩存中取出對(duì)應(yīng)key的request是不是已經(jīng)有緩存網(wǎng)絡(luò)返回結(jié)果了，如果有的話就直接返回結(jié)果
                Cache.Entry entry = mCache.get(request.getCacheKey());
                if (entry == null) {
                    request.addMarker("cache-miss");
                    // Cache miss; send off to the network dispatcher.
                    if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
//如果緩存沒(méi)有命中，則直接放進(jìn)網(wǎng)絡(luò)請(qǐng)求隊(duì)列中，在網(wǎng)絡(luò)請(qǐng)求線程中會(huì)請(qǐng)求網(wǎng)絡(luò)
                        mNetworkQueue.put(request);
                    }
                    continue;
                }

                // If it is completely expired, just send it to the network.
                if (entry.isExpired()) {
//判斷緩存的數(shù)據(jù)是否已經(jīng)過(guò)期，如果過(guò)期了則放進(jìn)網(wǎng)絡(luò)請(qǐng)求隊(duì)列中重新請(qǐng)求
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
                        mNetworkQueue.put(request);
                    }
                    continue;
                }

                // We have a cache hit; parse its data for delivery back to the request.
                request.addMarker("cache-hit");
//調(diào)用request的parseNetworkResponse來(lái)解析網(wǎng)絡(luò)返回結(jié)果，因?yàn)榫W(wǎng)絡(luò)返回可能是xml，string，json等等數(shù)據(jù)，這個(gè)地方可以自定義一個(gè)request來(lái)解析
                Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));
                request.addMarker("cache-hit-parsed");

                if (!entry.refreshNeeded()) {
//緩存數(shù)據(jù)是否需要重新刷新，如果不需要?jiǎng)t直接返回給主線程
                    // Completely unexpired cache hit. Just deliver the response.
                    mDelivery.postResponse(request, response);
                } else {
                    // Soft-expired cache hit. We can deliver the cached response,
                    // but we need to also send the request to the network for
                    // refreshing.
                    request.addMarker("cache-hit-refresh-needed");
                    request.setCacheEntry(entry);
                    // Mark the response as intermediate.
                    response.intermediate = true;

                    if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
                        // Post the intermediate response back to the user and have
                        // the delivery then forward the request along to the network.
//如果是需要刷新的則我們先返回結(jié)果，然后再把request返回網(wǎng)絡(luò)請(qǐng)求隊(duì)列中去刷新數(shù)據(jù)
                        mDelivery.postResponse(request, response, new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    mNetworkQueue.put(request);
                                } catch (InterruptedException e) {
                                    // Restore the interrupted status
                                    Thread.currentThread().interrupt();
                                }
                            }
                        });
                    } else {
                        // request has been added to list of waiting requests
                        // to receive the network response from the first request once it returns.
                        mDelivery.postResponse(request, response);
                    }
                }

            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
            }
        }
    }

我們看到上面的代碼就是說(shuō)明的我們圖片里面的意思，程序會(huì)循環(huán)運(yùn)行，首先會(huì)嘗試從緩存DiskBasedCache中取出請(qǐng)求的request，如果緩存DiskBasedCache中已經(jīng)有這個(gè)緩存的結(jié)果，則先判斷返回結(jié)果有沒(méi)有過(guò)期或者需要重新刷新，如果都不需要?jiǎng)t直接解析調(diào)用ExecutorDelivery返回給主線程即可。

6.NetworkDispatcher run

我們上面已經(jīng)看了緩存的調(diào)度線程，我們現(xiàn)在來(lái)看網(wǎng)絡(luò)的調(diào)度線程里面做了些啥，我們可以預(yù)想，這里面肯定就是實(shí)際地訪問(wèn)網(wǎng)絡(luò)的代碼了，這里面就是我們上面創(chuàng)建來(lái)的BasicNetWork來(lái)訪問(wèn)網(wǎng)絡(luò)了：

 @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            Request<?> request;
            try {
                // Take a request from the queue.
//首先從網(wǎng)絡(luò)請(qǐng)求隊(duì)列中取出request對(duì)象我們這里是以StringRequest為例
                request = mQueue.take();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }

            try {
                request.addMarker("network-queue-take");

                // If the request was cancelled already, do not perform the
                // network request.
//判斷下request是不是是取消狀態(tài)
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    request.notifyListenerResponseNotUsable();
                    continue;
                }

                addTrafficStatsTag(request);

                // Perform the network request.
//這個(gè)地方的mNetwork就是BasicNetWork，調(diào)用BasicNetwork的performRequest方法來(lái)請(qǐng)求網(wǎng)絡(luò)
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");

                // If the server returned 304 AND we delivered a response already,
                // we're done -- don't deliver a second identical response.
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
//判斷網(wǎng)絡(luò)請(qǐng)求的返回?cái)?shù)據(jù)是不是沒(méi)有修改，或者已經(jīng)發(fā)送過(guò)了這個(gè)請(qǐng)求則結(jié)束
                    request.finish("not-modified");
                    request.notifyListenerResponseNotUsable();
                    continue;
                }

                // Parse the response here on the worker thread.
//解析網(wǎng)絡(luò)返回?cái)?shù)據(jù)
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

                // Write to cache if applicable.
                // TODO: Only update cache metadata instead of entire record for 304s.
                if (request.shouldCache() && response.cacheEntry != null) {
//返回?cái)?shù)據(jù)需要緩存且返回?cái)?shù)據(jù)有數(shù)據(jù)則放進(jìn)緩存中
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }

                // Post the response back.
                request.markDelivered();
//往主線程發(fā)送返回的網(wǎng)絡(luò)結(jié)果
                mDelivery.postResponse(request, response);
                request.notifyListenerResponseReceived(response);
            } catch (VolleyError volleyError) {
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                parseAndDeliverNetworkError(request, volleyError);
                request.notifyListenerResponseNotUsable();
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                VolleyError volleyError = new VolleyError(e);
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                mDelivery.postError(request, volleyError);
                request.notifyListenerResponseNotUsable();
            }
        }
    }

這個(gè)方法跟上面的方法有點(diǎn)類(lèi)似，這里主要有一個(gè)不同的地方是要調(diào)用mNetwork對(duì)象的performRequest方法，這個(gè)mNetwork就是BasicNetwork對(duì)象，所以我們看下BasicNetwork對(duì)象的performRequest()方法：

 @Override
    public NetworkResponse performRequest(Request<?> request) throws VolleyError {
        long requestStart = SystemClock.elapsedRealtime();
        while (true) {
            HttpResponse httpResponse = null;
            byte[] responseContents = null;
            List<Header> responseHeaders = Collections.emptyList();
            try {
                // Gather headers.
//得到一些另外的請(qǐng)求頭具體可以看getCacheHeaders方法
                Map<String, String> additionalRequestHeaders =
                        getCacheHeaders(request.getCacheEntry());
//這里就是調(diào)用的AdaptedHttpStack的executeRequest來(lái)請(qǐng)求網(wǎng)絡(luò)(這里又包裝了HttpURLConnection和HttpClient訪問(wèn)網(wǎng)絡(luò))
                httpResponse = mBaseHttpStack.executeRequest(request, additionalRequestHeaders);
                int statusCode = httpResponse.getStatusCode();
//獲得到返回?cái)?shù)據(jù)的頭部
                responseHeaders = httpResponse.getHeaders();
                // Handle cache validation.
                if (statusCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
//如果返回的狀態(tài)碼是不修改的，那么則獲取緩存給NetworkResponse
                    Entry entry = request.getCacheEntry();
                    if (entry == null) {
                        return new NetworkResponse(HttpURLConnection.HTTP_NOT_MODIFIED, null, true,
                                SystemClock.elapsedRealtime() - requestStart, responseHeaders);
                    }
                    // Combine cached and response headers so the response will be complete.
                    List<Header> combinedHeaders = combineHeaders(responseHeaders, entry);
                    return new NetworkResponse(HttpURLConnection.HTTP_NOT_MODIFIED, entry.data,
                            true, SystemClock.elapsedRealtime() - requestStart, combinedHeaders);
                }

                // Some responses such as 204s do not have content.  We must check.
                InputStream inputStream = httpResponse.getContent();
                if (inputStream != null) {
                  responseContents =
                          inputStreamToBytes(inputStream, httpResponse.getContentLength());
                } else {
                  // Add 0 byte response as a way of honestly representing a
                  // no-content request.
                  responseContents = new byte[0];
                }

                // if the request is slow, log it.
                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
                logSlowRequests(requestLifetime, request, responseContents, statusCode);

                if (statusCode < 200 || statusCode > 299) {
                    throw new IOException();
                }
//不然就從網(wǎng)絡(luò)返回response取出返回的結(jié)果數(shù)據(jù)給NetworkResponse
                return new NetworkResponse(statusCode, responseContents, false,
                        SystemClock.elapsedRealtime() - requestStart, responseHeaders);
            } catch (SocketTimeoutException e) {
                attemptRetryOnException("socket", request, new TimeoutError());
            } catch (MalformedURLException e) {
                throw new RuntimeException("Bad URL " + request.getUrl(), e);
            } catch (IOException e) {
...........
            }
        }
    }

我們看到這個(gè)地方主要就是調(diào)用mBaseHttpStack的executeRequest方法，這個(gè)mBaseHttpStack在構(gòu)造BasicNetwork的時(shí)候會(huì)進(jìn)行包裝：

 @Deprecated
    public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
        mHttpStack = httpStack;
        mBaseHttpStack = new AdaptedHttpStack(httpStack);
        mPool = pool;
    }

可以看到這里的mBaseHttpStack就是AdaptedHttpStack對(duì)象，所以我們可以看到AdaptedHttpStack的executeRequest方法：

  @Override
    public HttpResponse executeRequest(
            Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
        org.apache.http.HttpResponse apacheResp;
        try {
//我們看到這個(gè)地方調(diào)用了mHttpStack的performRequest用來(lái)請(qǐng)求網(wǎng)絡(luò)
             apacheResp = mHttpStack.performRequest(request, additionalHeaders);
        } catch (ConnectTimeoutException e) {
            // BasicNetwork won't know that this exception should be retried like a timeout, since
            // it's an Apache-specific error, so wrap it in a standard timeout exception.
            throw new SocketTimeoutException(e.getMessage());
        }
//得到網(wǎng)絡(luò)返回的返回碼
        int statusCode = apacheResp.getStatusLine().getStatusCode();
//返回所有的消息報(bào)頭
        org.apache.http.Header[] headers = apacheResp.getAllHeaders();
        List<Header> headerList = new ArrayList<>(headers.length);
        for (org.apache.http.Header header : headers) {
            headerList.add(new Header(header.getName(), header.getValue()));
        }

        if (apacheResp.getEntity() == null) {
//返回的數(shù)據(jù)為空則直接就返回狀態(tài)碼和頭部列表
            return new HttpResponse(statusCode, headerList);
        }

        long contentLength = apacheResp.getEntity().getContentLength();
        if ((int) contentLength != contentLength) {
            throw new IOException("Response too large: " + contentLength);
        }
//將所有的信息封裝成HttpResponse對(duì)象
        return new HttpResponse(
                statusCode,
                headerList,
                (int) apacheResp.getEntity().getContentLength(),
                apacheResp.getEntity().getContent());
    }

我們看到這里的主要代碼也就是調(diào)用mHttpStack的performRequest方法來(lái)請(qǐng)求網(wǎng)絡(luò)，這里的mHttpStack就是前面在構(gòu)造newRequestQueue時(shí)候的HurlStack和HttpClientStack，這里面就是具體的HttpClient與HttpURLConnection訪問(wèn)網(wǎng)絡(luò)的內(nèi)容了，具體的這兩個(gè)怎么使用我們不細(xì)究。到這里我們網(wǎng)絡(luò)請(qǐng)求已經(jīng)返回結(jié)果了。那么我們來(lái)看看我們是怎么發(fā)送我們返回結(jié)果到主線程的。

7.mDelivery postResponse(request, response)

我們看到前面已經(jīng)網(wǎng)絡(luò)請(qǐng)求數(shù)據(jù)已經(jīng)返回了，我們最后會(huì)解析完發(fā)送給主線程，我們馬上就來(lái)看看怎么發(fā)送的吧：

   @Override
    public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
        request.markDelivered();
        request.addMarker("post-response");
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
    }

這里就是我們發(fā)送數(shù)據(jù)到主線程的代碼，我們看到這里會(huì)執(zhí)行ResponseDeliveryRunnable線程，我們干脆就直接來(lái)看這個(gè)線程干了什么：

   public void run() {
            // NOTE: If cancel() is called off the thread that we're currently running in (by
            // default, the main thread), we cannot guarantee that deliverResponse()/deliverError()
            // won't be called, since it may be canceled after we check isCanceled() but before we
            // deliver the response. Apps concerned about this guarantee must either call cancel()
            // from the same thread or implement their own guarantee about not invoking their
            // listener after cancel() has been called.

            // If this request has canceled, finish it and don't deliver.
            if (mRequest.isCanceled()) {
                mRequest.finish("canceled-at-delivery");
                return;
            }

            // Deliver a normal response or error, depending.
            if (mResponse.isSuccess()) {
//返回?cái)?shù)據(jù)成功則調(diào)用mRequest的deliverResponse返回結(jié)果，不然返回錯(cuò)誤
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }

            // If this is an intermediate response, add a marker, otherwise we're done
            // and the request can be finished.
            if (mResponse.intermediate) {
                mRequest.addMarker("intermediate-response");
            } else {
                mRequest.finish("done");
            }

            // If we have been provided a post-delivery runnable, run it.
            if (mRunnable != null) {
                mRunnable.run();
            }
       }

我看看到這個(gè)方法主要調(diào)用mRequest的deliverResponse來(lái)返回?cái)?shù)據(jù)，這個(gè)mRequest我們是以StringRequest為例的，所以我們看StringRequest的deliverResponse方法：

  @Override
    protected void deliverResponse(String response) {
        Response.Listener<String> listener;
        synchronized (mLock) {
            listener = mListener;
        }
        if (listener != null) {
            listener.onResponse(response);
        }
    }

這個(gè)方法主要是調(diào)用的listener的onResponse進(jìn)行回調(diào)的。所以就會(huì)調(diào)用到我們給StringRequest設(shè)置的listener了。到這里我們整個(gè)流程也就講完了，非常的通暢，跟前面的圖片完全符合呀。
總結(jié)：Volley的代碼非常清晰，思路也非常清晰，只要照著圖就能了解個(gè)大概，這篇是網(wǎng)絡(luò)框架的第一篇，希望我們接下來(lái)能把相應(yīng)的網(wǎng)絡(luò)框架拿出來(lái)說(shuō)說(shuō)，大家一起努力。。。。