0. Avant-propos

En fait, cet article n'est écrit que dans un seul but, bien que VolleyC'est génial à utiliser, mais l'intervieweur vous demande comment l'implémenter en interne. Si vous n'avez pas vu le code source, aux yeux de l'intervieweur, vous êtes le. comme quelqu'un qui tient un livreVolleyIl n'y a aucune différence entre un lycéen utilisant un manuel. Comme le dit le proverbe, savoir l’utiliser est une chose, mais le comprendre en profondeur en est une autre.

1. VoléeAnalyse du code source

1.1 Volée Entrée

VolleyLa première chose à obtenir est l'instance RequestQueue. Le code source appelle directement la méthode newRequestQueue .

public static RequestQueue newRequestQueue(Context context) {  
    return newRequestQueue(context, null);  
}  
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {  
    File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);  
    String userAgent = "volley/0";  
    try {  
        String packageName = context.getPackageName();  
        PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);  
        userAgent = packageName + "/" + info.versionCode;  
    } catch (NameNotFoundException e) {  
    }  
    if (stack == null) {  
        if (Build.VERSION.SDK_INT >= 9) {  
            stack = new HurlStack();  
        } else {  
            stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));  
        }  
    }  
    Network network = new BasicNetwork(stack);  
    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);  
    queue.start();  
    return queue;  
}

Comme vous pouvez le voir dans le code source ci-dessus, il est déterminé que la pile entrante est vide, puis crée un objet HttpStack selon la version du système, qui est supérieure ou égale à 9, créez une instance de HurlStack (utilisez en interne HttpURLConnection) , sinon créez une < Une instance de ??>HttpClientStack (en interne en utilisant HttpClient) . Il le fait parce que?:

(1)HttpURLConnection dans < Il y a un BUG dans la version de ??>9 qui appelle imputStream.close() provoquera le pool de connexions échouer , relativement parlant, HTTPClient a moins de BOGUES dans les versions du système inférieures à 9 .

2) et dans les versions supérieures ou égales à 9, L'implémentation de HttpURLConnection présente plus d'avantages, API est plus simple, plus petite, a une fonction de compression et 4.0Le mécanisme de mise en cache ajouté ultérieurement (tel que le cache local, le cache 304, le cache du serveur ). Après avoir créé HttpStack, il l'utilise comme paramètre pour créer un objet Network, puis crée un objet

RequestQueue< basé sur l'objet Network ??>, et appelez sa méthode start() pour démarrer, puis renvoyez l'instance.

public void start() {  
    stop(); 
    mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);  
    mCacheDispatcher.start();  
for (int i = 0; i < mDispatchers.length; i++) { //默認(rèn)循環(huán)4次 
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,  mCache, mDelivery);  
        mDispatchers[i] = networkDispatcher;  
        networkDispatcher.start();  
    }  
}

這里CacheDispatcher和NetworkDispatcher都是繼承自Thread的，也就是說(shuō)當(dāng)調(diào)用了Volley.newRequestQueue(context)之后，一個(gè)緩存線程和四個(gè)網(wǎng)絡(luò)請(qǐng)求線程會(huì)一直在后臺(tái)運(yùn)行，并等待網(wǎng)絡(luò)請(qǐng)求的到來(lái)。

1.3 RequestQueue.add()

既然上面已經(jīng)迫不及待等待網(wǎng)絡(luò)請(qǐng)求的到來(lái)了，那么是時(shí)候?qū)⑽覀兊?/span>Request添加進(jìn)隊(duì)列了。

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;  
    }  
    // Insert request into stage if there&#39;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 &#39;null&#39; queue for this cacheKey, indicating there is now a request in  
            // flight.  
            mWaitingRequests.put(cacheKey, null);  
            mCacheQueue.add(request);  
        }  
        return request;  
    }  
}

在第11行的時(shí)候會(huì)判斷當(dāng)前的請(qǐng)求是否可以緩存，默認(rèn)情況下是可以緩存的，除非主動(dòng)調(diào)用了Request的setShouldCache(false)方法來(lái)不允許其進(jìn)行緩存。因此默認(rèn)情況下會(huì)將該請(qǐng)求加入到緩存隊(duì)列，否則直接加入網(wǎng)絡(luò)請(qǐng)求隊(duì)列。下面看看緩存線程中的run方法。

1.4 CacheDispatcher中的run()

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.  
                final Request<?> request = mCacheQueue.take();  
                request.addMarker("cache-queue-take");  
                // If the request has been canceled, don&#39;t bother dispatching it.  
                if (request.isCanceled()) {  
                    request.finish("cache-discard-canceled");  
                    continue;  
                }  
                // Attempt to retrieve this item from cache.  
                Cache.Entry entry = mCache.get(request.getCacheKey());  
                if (entry == null) {  
                    request.addMarker("cache-miss");  
                    // Cache miss; send off to the network dispatcher.  
                    mNetworkQueue.put(request);  
                    continue;  
                }  
                // If it is completely expired, just send it to the network.  
                if (entry.isExpired()) {  
                    request.addMarker("cache-hit-expired");  
                    request.setCacheEntry(entry);  
                    mNetworkQueue.put(request);  
                    continue;  
                }  
                // We have a cache hit; parse its data for delivery back to the request.  
                request.addMarker("cache-hit");  
                Response<?> response = request.parseNetworkResponse(  
                        new NetworkResponse(entry.data, entry.responseHeaders));  
                request.addMarker("cache-hit-parsed");  
                if (!entry.refreshNeeded()) {  
                    // 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;  
                    // Post the intermediate response back to the user and have  
                    // the delivery then forward the request along to the network.  
                    mDelivery.postResponse(request, response, new Runnable() {  
                        @Override  
                        public void run() {  
                            try {  
                                mNetworkQueue.put(request);  
                            } catch (InterruptedException e) {  
                                // Not much we can do about this.  
                            }  
                        }  
                    });  
                }  
            } catch (InterruptedException e) {  
                // We may have been interrupted because it was time to quit.  
                if (mQuit) {  
                    return;  
                }  
                continue;  
            }  
        }  
}

可以看到while(true)的循環(huán)說(shuō)明緩存線程始終是在運(yùn)行，接著會(huì)嘗試從緩存當(dāng)中取出響應(yīng)結(jié)果，如何為空則把這條請(qǐng)求加入到網(wǎng)絡(luò)請(qǐng)求隊(duì)列中，否則判斷該緩存是否已過(guò)期，如果已經(jīng)過(guò)期那么肯定還是同上處理，沒(méi)有過(guò)期就直接使用緩存中的數(shù)據(jù)。

之后就是和網(wǎng)絡(luò)請(qǐng)求隊(duì)列請(qǐng)求到數(shù)據(jù)后一樣的數(shù)據(jù)解析邏輯以及解析結(jié)果回調(diào)邏輯。

1.5 NetworkDispatcher中的run()

接下來(lái)就是分析正常情況下，沒(méi)有緩存的情況下，網(wǎng)絡(luò)請(qǐng)求是什么樣子的。直接看網(wǎng)絡(luò)請(qǐng)求線程中的run()。

public void run() {  
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
        Request<?> request;  
        while (true) {  
            try {  
                // Take a request from the queue.  
                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.  
                if (request.isCanceled()) {  
                    request.finish("network-discard-cancelled");  
                    continue;  
                }  
                addTrafficStatsTag(request);  
                // Perform the network request.  
                NetworkResponse networkResponse = mNetwork.performRequest(request);  
                request.addMarker("network-http-complete");  
                // If the server returned 304 AND we delivered a response already,  
                // we&#39;re done -- don&#39;t deliver a second identical response.  
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {  
                    request.finish("not-modified");  
                    continue;  
                }  
                // Parse the response here on the worker thread.  
                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) {  
                    mCache.put(request.getCacheKey(), response.cacheEntry);  
                    request.addMarker("network-cache-written");  
                }  
                // Post the response back.  
                request.markDelivered();  
                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));  
            }  
        }  
    }  
}

while(true)循環(huán)說(shuō)明網(wǎng)絡(luò)請(qǐng)求線程也是在不斷運(yùn)行的。在第25行可以看到調(diào)用了Network的performRequest()方法發(fā)送網(wǎng)絡(luò)請(qǐng)求，而Network是一個(gè)接口，這里具體的實(shí)現(xiàn)是BasicNetwork，我們來(lái)看下它的performRequest()方法，如下所示：

public NetworkResponse performRequest(Request<?> request) throws VolleyError {  
        long requestStart = SystemClock.elapsedRealtime();  
        while (true) {  
            HttpResponse httpResponse = null;  
            byte[] responseContents = null;  
            Map<String, String> responseHeaders = new HashMap<String, String>();  
            try {  
                // Gather headers.  
                Map<String, String> headers = new HashMap<String, String>();  
                addCacheHeaders(headers, request.getCacheEntry());  
                httpResponse = mHttpStack.performRequest(request, headers);  
                StatusLine statusLine = httpResponse.getStatusLine();  
                int statusCode = statusLine.getStatusCode();  
                responseHeaders = convertHeaders(httpResponse.getAllHeaders());  
                // Handle cache validation.  
                if (statusCode == HttpStatus.SC_NOT_MODIFIED) {  
                    return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,  
                            request.getCacheEntry() == null ? null : request.getCacheEntry().data,  
                            responseHeaders, true);  
                }  
                // Some responses such as 204s do not have content.  We must check.  
                if (httpResponse.getEntity() != null) {  
                  responseContents = entityToBytes(httpResponse.getEntity());  
                } 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, statusLine);  
                if (statusCode < 200 || statusCode > 299) {  
                    throw new IOException();  
                }  
                return new NetworkResponse(statusCode, responseContents, responseHeaders, false);  
            } catch (Exception e) {  
                ……  
            }  
        }  
}

里面除去一些網(wǎng)絡(luò)請(qǐng)求的細(xì)節(jié)，看到在第11行調(diào)用了HttpStack的performRequest()方法，這里的HttpStack就是在一開(kāi)始調(diào)用newRequestQueue()方法是創(chuàng)建的實(shí)例，之后會(huì)將服務(wù)器返回的數(shù)據(jù)組裝成一個(gè)NetworkResponse對(duì)象進(jìn)行返回。

收到了NetworkResponse這個(gè)返回值后會(huì)調(diào)用Request的parseNetworkResponse()方法來(lái)解析NetworkResponse中的數(shù)據(jù)，以及將數(shù)據(jù)寫入到緩存，這個(gè)方法的實(shí)現(xiàn)是交給Request的子類來(lái)完成的，因?yàn)椴煌N類的Request解析的方式也肯定不同。在解析完了NetworkResponse中的數(shù)據(jù)之后，又會(huì)調(diào)用ExecutorDelivery的postResponse()方法來(lái)回調(diào)解析出的數(shù)據(jù)，代碼如下所示：

public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
 }
};
}
# postResponse方法
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {  
    request.markDelivered();  
    request.addMarker("post-response");  
    mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}

在該類的構(gòu)造函數(shù)中傳入了一個(gè)主線程創(chuàng)建的handler，最后一行代碼在mResponsePoster的execute()方法中傳入一個(gè)ResponseDeliveryRunnable對(duì)象，這樣就可以通過(guò)handler.post（runnable）切換到了主線程。我們繼續(xù)看下這個(gè)Runnable中的run()方法中的代碼是什么樣的：

private class ResponseDeliveryRunnable implements Runnable {  
    private final Request mRequest;  
    private final Response mResponse;  
    private final Runnable mRunnable;  
  
    public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {  
        mRequest = request;  
        mResponse = response;  
        mRunnable = runnable;  
    }  
  
    @SuppressWarnings("unchecked")  
    @Override  
    public void run() {  
        // 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()) {  
            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();  
        }  
   }  
}

其中在第22行調(diào)用了Request的deliverResponse()方法，這個(gè)和parseNetworkResponse()方法一樣都是我們?cè)谧远xRequest時(shí)需要重寫的方法，每一條網(wǎng)絡(luò)請(qǐng)求的響應(yīng)都是回調(diào)到這個(gè)方法中，再在這個(gè)方法中將響應(yīng)的數(shù)據(jù)回調(diào)到Listener的onResponse()方法中，即我們創(chuàng)建Request時(shí)傳入的那個(gè)listener。