Volley源码分析

在进行网络请求时，相信大家都用过Volley，Volley是Google推出来的网络访问框架，它内部仅仅是对HttpUrlConnection和HttpClient的进一步封装，使得网络请求变得简单，而且非常适合频繁的小数量数据的网络请求，使用起来非常简单，三句话就可以搞定网络请求，仅仅会使用还不行，现在我就来带你分析一下Volley的实现原理。先看看使用

//创建请求队列

RequestQueue queue = Volley.newRequestQueue(getApplication());
        //创建请求
        StringRequest request = new StringRequest(path, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                //请求成功
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                //请求失败
            }
        });

//添加请求队列
queue.add(request);

以上就是Volley的网络请求，非常简单。首先我们来看看第一句话，使用Volley类的newRequestQueue()返回RequestQueue对象，我们跟踪代码

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

public static RequestQueue newRequestQueue(Context context, HttpStack stack)
    {
    	return newRequestQueue(context, stack, -1);
    }

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
        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 {
                // Prior to Gingerbread, HttpUrlConnection was unreliable.
                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }

        Network network = new BasicNetwork(stack);
        
        RequestQueue queue;
        if (maxDiskCacheBytes <= -1)
        {
        	// No maximum size specified
        	queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        }
        else
        {
        	// Disk cache size specified
        	queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
        }

        queue.start();

        return queue;
    }

我们可以看到还有第二个参数HttpStack和第三个参数int，HttpStack是对网络请求的API的进一步的封装，如果要将OkHttp封装到Volley中，只要将其封装到HttpStack中即可，要想其支持Https请求，请看： http://blog.csdn.net/cj_286/article/details/55195272，maxDiskCacheBytes是缓存的大小，单位是byte，如果不设置默认是5 * 1024 * 1024。如果当前SDK版本大于等于9的时候，网络请求HttpStack封装的是HttpUrlConnection，SDK版本小于9的时候，网络请求HttpStack封装的是HttpClient。Network network = new BasicNetwork(stack);是对HttpStack的进一步封装，封装成Network对象。

public interface Network {
    /**
     * Performs the specified request.
     * @param request Request to process
     * @return A {@link NetworkResponse} with data and caching metadata; will never be null
     * @throws VolleyError on errors
     */
    public NetworkResponse performRequest(Request<?> request) throws VolleyError;
}

用于网络请求的框架有了，下面就是创建一个请求队列，用于存放网络请求的Request。queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);

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

public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;//网络缓存 new DiskBasedCache(cacheDir)
        mNetwork = network;//网络请求框架
        mDispatchers = new NetworkDispatcher[threadPoolSize];//用于网络请求的线程Thread，只有4个
        mDelivery = delivery;//响应数据时，将子线程切换到主线程
    }

mDelivery =  new ExecutorDelivery(new Handler(Looper.getMainLooper()))用于响应分发请求的响应数据，主要是从工作线程切换到UI线程。原理也是使用的Handler.

public class ExecutorDelivery implements ResponseDelivery {
    /** Used for posting responses, typically to the main thread. */
    private final Executor mResponsePoster;

    /**
     * Creates a new response delivery interface.
     * @param handler {@link Handler} to post responses on
     */
    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);
            }
        };
    }
......
}

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

首先开启线程前，先执行以下停止操作，防止之前有在运行。

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

mCacheDispatcher和mDispatcher都是Thread，CacheDispatcher extends Thread  ，NetworkDispatcher extends Thread，用于缓存的读取和网络请求。 mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery); mCacheDispatcher.start();开启线程，在看看线程的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();

        Request<?> request;
        while (true) {
            // release previous request object to avoid leaking request object when mQueue is drained.
            request = null;
            try {
                // Take a request from the queue.
                request = mCacheQueue.take();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }
            try {
                request.addMarker("cache-queue-take");

                // If the request has been canceled, don'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.
                    final Request<?> finalRequest = request;
                    mDelivery.postResponse(request, response, new Runnable() {
                        @Override
                        public void run() {
                            try {
                                mNetworkQueue.put(finalRequest);
                            } catch (InterruptedException e) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
            }
        }
    }

mCache.initialize();是初始化缓存，将本地缓存读取到内存中。

public synchronized void initialize() {
        if (!mRootDirectory.exists()) {
            if (!mRootDirectory.mkdirs()) {
                VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
            }
            return;
        }

        File[] files = mRootDirectory.listFiles();
        if (files == null) {
            return;
        }
        for (File file : files) {
            BufferedInputStream fis = null;
            try {
                fis = new BufferedInputStream(new FileInputStream(file));
                CacheHeader entry = CacheHeader.readHeader(fis);
                entry.size = file.length();
                putEntry(entry.key, entry);
            } catch (IOException e) {
                if (file != null) {
                   file.delete();
                }
            } finally {
                try {
                    if (fis != null) {
                        fis.close();
                    }
                } catch (IOException ignored) { }
            }
        }
    }

mCacheQueue是PriorityBlockingQueue<Request<?>>对象，PriorityBlockingQueue是阻塞队列，take()方法是阻塞方法，在BlockingQueue队列中有数据时才会获取，如果没有数据时就会等待，直到队列中有数据为止，Volley也是利用可java的BlockingQueue的这点特性，将复杂的问题简单化。让Cache Thread不断的去读取缓存队列的的请求数据，一旦缓存队列中有请求数据时，就获取Request，查看其有没有被取消，如果取消就继续去读取下一个Request。

if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");
                    continue;
                }

查看本地缓存中是否有该请求，如果没有就将其Request添加到Network Queue，网络队列和缓存队列一样，都是PriorityBlockingQueue类型，然后继续读取下一个Request。

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

如果有缓存，看这缓存是否过期，如果过期了，就将其Request添加到Network Queue.

if (entry.isExpired()) {
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    mNetworkQueue.put(request);
                    continue;
                }

如果没有过期就将其缓存中的数据封装成Response对象

Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));

然后将其响应体给调用者的成功监听

mDelivery.postResponse(request, response);

调用ExecutorDelivery的postResponse去在UI线程中去调用Request中的成功监听，

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

mResponsePoster.execute()就是将任务通过Handler放到UI线程中去执行

mResponsePoster = new Executor() {
            @Override
            public void execute(Runnable command) {
                handler.post(command);
            }
        };

成功监听的回调就是在ResponseDelivery中实现的

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

再次的去判断是否被取消，如果请求成功就回调Request上的成功的监听，失败就回调失败的监听。

if (mResponse.isSuccess()) {
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }

到这里如果有网络缓存的处理过程分析玩了，那么没有缓存呢，还记得之前CacherDispatcher的run方法中，如果没有缓存和缓存过期就会将Request添加到mNetworkQueue队列中去。然后我们在回到RequestQueue的start()方法中，开启缓存线程之后，有开启了4个网络请求线程，主要任务就是不断的读取mNetworkQueue中的Request用于网络请求。

for (int i = 0; i < mDispatchers.length; i++) {
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                    mCache, mDelivery);
            mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }

我们分析一下NetworkDispatcher中的run()方法

public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        Request<?> request;
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            // release previous request object to avoid leaking request object when mQueue is drained.
            request = null;
            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're done -- don'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) {
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                parseAndDeliverNetworkError(request, volleyError);
            } 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 = mQueue.take();读取Request请求，然后看时候被取消，如果没有就发起真正的网络请求。

// Perform the network request.
NetworkResponse networkResponse = mNetwork.performRequest(request);

Network是将网络请求进行了封装，在performRequest()中调用的真正的网络API进行了网络请求，然后将网络返回的数据封装成NetworkResponse返回。
如果服务器返回304年和我们已经发表了回应,就别提供第二个相同的反应。

if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }

如果不存在以上的情况就将网络请求下来的数据封装成Response类型

Response<?> response = request.parseNetworkResponse(networkResponse);

如果需要缓存就将其缓存起来

if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);//getCacheKey()-->mMethod + ":" + mUrl;请求方式+url
                    request.addMarker("network-cache-written");
                }

然后将其发送到成功的请求监听中去

// Post the response back.
                request.markDelivered();
                mDelivery.postResponse(request, response);

然后这个就和缓存的响应步骤一样了

public void postResponse(Request<?> request, Response<?> response) {
        postResponse(request, response, null);
    }

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

 mResponsePoster = new Executor() {
            @Override
            public void execute(Runnable command) {
                handler.post(command);
            }
        };

到这里缓存和网络请求都说完了，但是这只是执行newRequestQueue()方法后Volley内部所做的事情，但是这时mCacheQueue和mNetworkQueue中并没有Request数据，我们还没有添加。接下来我们会创建我们自己的Request对象

StringRequest request = new StringRequest(path, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                
            }
        });

这个StringRequest是Volley提供的，我们也可以重写Request类来定义属于我们的请求方式。

接下来就是要将Request添加到RequestQueue中。queue.add(request);

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);//将RequestQueue设置到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;
        }

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

mCurrentRequests是Set集合，用于存储正在处理的Requset请求，为什么要存储起来呢，为了方便管理，比如要取消所有的请求，就可以遍历这个集合去取消网络请求。

如果请求已经设为不需要缓存，就直接将其添加到mNetworkQueue中去，直接进行网络请求，无需添加到mCacheQueue中去，查看是否有缓存了。

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

mWaitingRequests是Map<String, Queue<Request<?>>>集合，为什么需要此集合呢，它主要是避免相同的网络请求多次执行，如果相同的网络我请求的3次，我没有必要真正的去发起三次请求，因为三次的请求相同，没有必要，因为三次的请求结果是相同的。比如我这时来了三次相同的请求，第一次请求时判断mWaitingRequests中是否有该请求mWaitingRequests.containsKey(cacheKey)，如果没有（第一次肯定没有）走else分支，将其添加到mWaitingRequests集合和mCacheQueue队列中。

mWaitingRequests.put(cacheKey, null);
                mCacheQueue.add(request);

第二次请求来时mWaitingRequests.containsKey(cacheKey)返回ture，走if分支，将第二次请求添加到Queue等待队列中去，当然第三次的请求也会被添加到等待队列中去。那么等待队列中的请求何时执行呢，我们还记得NetworkDispatcher网络请求中的request.finish(String)方法吗，该方法中会调用mRequestQueue.finish(this);方法，我们看看此方法，这时会将等待队列中的请求获取出来添加到缓存队列中去，因为这是此请求已经有缓存了，从而避免了三次相同的网络请求发起不必要的请求。

<T> void finish(Request<T> request) {
        // Remove from the set of requests currently being processed.
        synchronized (mCurrentRequests) {
            mCurrentRequests.remove(request);//将request从但前任务重移除
        }
        synchronized (mFinishedListeners) {
          for (RequestFinishedListener<T> listener : mFinishedListeners) {
            listener.onRequestFinished(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);//添加到缓存队列中去
                }
            }
        }
    }

到这里Volley的网络请求源码已经分析完了。其实就是Cache Thread和Network Thread不断的获取mCacheQueue和mNetworkQueue中的Request,因为mCacheQueue和mNetworkQueue都是阻塞队列，只有队列中有数据的时候才会去获取，没有数据的时候就会等待，只要有数据为止。Volley巧妙地利用了java的BlockingQueue的这个特点，完美的实现Request的添加与获取，简化了代码的实现。以下附上分析图