Volley源码解析

抽时间看了下Volley的源码，感觉这个框架还是很不错的，这里对其源码进行分析。

主要从以下几个方面分析：

1. 简要介绍 Volley 的使用
2. Volley 访问网络的整体流程
3. 对源码中一些重要的类的总结
4. 一些总结

简要介绍 Volley 的使用

这个不是文章的重点，所以就简单介绍一下。

// 创建请求队列
RequestQueue mQueue = Volley.newRequestQueue(context);

// 创建请求
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);  
                        }  
                    });  
                    
// 添加请求到队列中
mQueue.add(stringRequest);

更具体的使用可以参考博客 Volley使用

Volley 访问网络的整体流程

这里从使用方法开始进行分析。

首先通过 Volley#newRequestQueue() 创建请求队列。
在Volley类中，一共就提供了两个静态的重载方法 newRequestQueue()
主要看下 newRequestQueue(Context, HttpStack)

// Volley#newRequestQueue()

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) {
    }

    // 创建 HttpStack
    if (stack == null) {
        if (Build.VERSION.SDK_INT >= 9) { // 根据sdk版本选择HttpUrlConnection或者HttpClient
            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;
}

可以看到，其中主要创建了Network，HttpStack，RequestQueue，并启动了RequestQueue
最终网络访问就封装在HttpStack中，这个后面再看
先跟进到 RequestQueue#start()中看下

// RequestQueue#start()

public void start() {
    stop();  // Make sure any currently running dispatchers are stopped.
    
    // 启动缓存派发器
    mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
    mCacheDispatcher.start();

    // 启动网络派发器
    for (int i = 0; i < mDispatchers.length; i++) {
        NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                mCache, mDelivery);
        mDispatchers[i] = networkDispatcher;
        networkDispatcher.start();
    }
}

其中可以看到，就是启动了缓存派发器和网络派发器

在构建了请求队列后，发起请求只要把请求添加到请求队列中就好了，接下来看下RequestQueue#add()代码
这里挑一些主要的代码看

// RequestQueue#add()

// RequestQueue中维护了两个队列，一个是缓存队列，一个是网络请求队列，之后派发器会从这两个队列中获取请求
private final PriorityBlockingQueue<Request<?>> mCacheQueue =
new PriorityBlockingQueue<Request<?>>();
private final PriorityBlockingQueue<Request<?>> mNetworkQueue =
    new PriorityBlockingQueue<Request<?>>();

public <T> Request<T> add(Request<T> request) {
    // 省略 ...
    
    // 如果请求不需要缓存的话，直接交给网络请求队列去执行，默认是需要缓存的
    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 {
            // 没有相同的请求在执行中，就把这个请求放入缓存队列中
            mWaitingRequests.put(cacheKey, null);
            mCacheQueue.add(request);
        }
        return request;
    }
}

从上面代码中可以看到，请求需要缓存的话，会加入到缓存队列中，交给缓存派发器处理，否则交给网络请求派发器处理
接下来看下缓存派发器对请求的处理
由于 CacheDispatcher 和 NetworkDispatcher 都是继承自 Thread ，　所以主要看其 run() 函数

// CacheDispatcher#run()

public void run() {
    // 对缓存池进行初始化
    mCache.initialize();

    while (true) { // 死循环不断处理请求
        try {
            // 从缓存队列中获取请求，这个缓存队列就是 RequestQueue 中看到的缓存队列
            // 如果队列为空，会阻塞在这个地方
            final Request<?> request = mCacheQueue.take();
            request.addMarker("cache-queue-take");

            // 请求取消什么都不做
            if (request.isCanceled()) {
                request.finish("cache-discard-canceled");
                continue;
            }

            // 从缓存池中获取请求缓存的内容
            Cache.Entry entry = mCache.get(request.getCacheKey());
            if (entry == null) {
                request.addMarker("cache-miss");
                // 缓存池中没有缓存此请求，也加入到网络请求队列中去
                mNetworkQueue.put(request);
                continue;
            }

            // 请求过期，也加入网络请求队列
            if (entry.isExpired()) {
                request.addMarker("cache-hit-expired");
                request.setCacheEntry(entry);
                mNetworkQueue.put(request);
                continue;
            }

            request.addMarker("cache-hit");
            // 根据缓存中获取的内容构建请求的回复
            Response<?> response = request.parseNetworkResponse(
                    new NetworkResponse(entry.data, entry.responseHeaders));
            request.addMarker("cache-hit-parsed");

            if (!entry.refreshNeeded()) {
                // 缓存不需要刷新，直接交给 ResponseDelivery 去处理，ResponseDelivery后面再看
                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;

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

从上面可以看到，代码不多，也很好理解，如果有缓存，就取出来去处理，没有或者过期，就加入到网络请求队列中去请求，需要网络请求的有几个地方：1. 请求不需要缓存 2. 请求在缓存中没有找到 3. 请求的缓存过期 4. 请求的缓存需要刷新
接下来就看下网络请求派发器
NetworkDispatcher 也是继承 Thread，所以也直接看 run() 函数

public void run() {
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    while (true) { // 一样是死循环不断处理请求
        long startTimeMs = SystemClock.elapsedRealtime();
        Request<?> request;
        try {
            // 这个地方会阻塞，这个队列就是 RequestQueue 中的网络队列
            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 (request.isCanceled()) {
                request.finish("network-discard-cancelled");
                continue;
            }

            addTrafficStatsTag(request);

            // 执行网络请求 其中真正执行的是 httpStack.performRequest
            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;
            }

            // 对返回的内容进行处理，parseNetworkResponse 需要我们重写，不过框架提供了一些常用的比如 StringRequest 和 JsonRequest
            Response<?> response = request.parseNetworkResponse(networkResponse);
            request.addMarker("network-parse-complete");

            // 存到缓存中
            if (request.shouldCache() && response.cacheEntry != null) {
                mCache.put(request.getCacheKey(), response.cacheEntry);
                request.addMarker("network-cache-written");
            }

            request.markDelivered();
            // 交给 ResponseDelivery 进一步处理
            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);
        }
    }
}

可以看到，在 NetworkDispatcher 中，最主要的就是调用了 mNetwork.performRequest(request) 执行网络请求，而在 Network 是个接口，具体实现类是 BasicNetwork，在BasicNetwork#performRequest()中调用 httpResponse = mHttpStack.performRequest(request, headers)，这里的 mHttpStack 就是前面看到的 HurlStack 和 HttpClientStack。而在 HttpStack 的 performRequest() 中就是具体的网络请求，看下 HurlStack 的。

// 这块就比较熟悉了，就是之前经常用的网络请求

public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
        throws IOException, AuthFailureError {
    String url = request.getUrl();
    HashMap<String, String> map = new HashMap<String, String>();
    map.putAll(request.getHeaders());
    map.putAll(additionalHeaders);
    if (mUrlRewriter != null) {
        String rewritten = mUrlRewriter.rewriteUrl(url);
        if (rewritten == null) {
            throw new IOException("URL blocked by rewriter: " + url);
        }
        url = rewritten;
    }
    URL parsedUrl = new URL(url);
    HttpURLConnection connection = openConnection(parsedUrl, request);
    for (String headerName : map.keySet()) {
        connection.addRequestProperty(headerName, map.get(headerName));
    }
    setConnectionParametersForRequest(connection, request);
    // Initialize HttpResponse with data from the HttpURLConnection.
    ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
    int responseCode = connection.getResponseCode();
    if (responseCode == -1) {
        // -1 is returned by getResponseCode() if the response code could not be retrieved.
        // Signal to the caller that something was wrong with the connection.
        throw new IOException("Could not retrieve response code from HttpUrlConnection.");
    }
    StatusLine responseStatus = new BasicStatusLine(protocolVersion,
            connection.getResponseCode(), connection.getResponseMessage());
    BasicHttpResponse response = new BasicHttpResponse(responseStatus);
    if (hasResponseBody(request.getMethod(), responseStatus.getStatusCode())) {
        response.setEntity(entityFromConnection(connection));
    }
    for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
        if (header.getKey() != null) {
            Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
            response.addHeader(h);
        }
    }
    return response;
}

在上面我们看到，最终会调用 ResponseDelivery#postResponse()
ExecutorDelivery 是　ResponseDelivery 的实现类，可以看下 ExecutorDelivery#postResponse()

// ExecutorDelivery#postResponse()

private final Executor mResponsePoster;
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
    request.markDelivered();
    request.addMarker("post-response");
    // 执行任务
    mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}

// ResponseDeliveryRunnable#run()

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

        if (mResponse.isSuccess()) {
            // 这个就是 request 中自己实现的，在 StringRequest 和 JsonRequest 中都是直接调用了 listener.onResponse()
            mRequest.deliverResponse(mResponse.result);
        } else {
            mRequest.deliverError(mResponse.error);
        }

        if (mResponse.intermediate) {
            mRequest.addMarker("intermediate-response");
        } else {
            mRequest.finish("done");
        }

        // 如果有需要执行的任务，会执行，前面缓存需要刷新的话，就会在这个地方进行网络调用
        if (mRunnable != null) {
            mRunnable.run();
        }
   }

以上就是请求的主要流程了，下面附上一张流程图

上面分析中没有提到 Volley 中的重试机制，其实在 BasicNetwork#performRequest() 中实现了失败重试机制。

public NetworkResponse performRequest(Request<?> request) throws VolleyError {
    long requestStart = SystemClock.elapsedRealtime();
    // 这个循环保证了失败后可以重新请求
    while (true) {
        // 省略代码 ...
        try {
            // 执行网络请求
            httpResponse = mHttpStack.performRequest(request, headers);
            // 省略代码 ...
        } catch (SocketTimeoutException e) {
            // 这里通过捕获异常来重试，这里没有捕捉 VolleyError 的异常，所以抛出 VolleyError 异常就会结束循环，不再重试了
            attemptRetryOnException("socket", request, new TimeoutError());
        }
        // 省略代码 ...
    }
}

private static void attemptRetryOnException(String logPrefix, Request<?> request,
        VolleyError exception) throws VolleyError {
    RetryPolicy retryPolicy = request.getRetryPolicy();
    int oldTimeout = request.getTimeoutMs();

    try {
        retryPolicy.retry(exception); // 重试策略，如果不需要重试，就会抛出 VolleyError 的异常
    } catch (VolleyError e) {
        request.addMarker(
                String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
        throw e;
    }
    request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
}

对源码中一些重要的类的总结

其实在上面讲流程的时候已经分析了主要的类了，这里主要做个总结。
Volley中主要的类有这些：

• Volley: 提供了构建 RequestQueue 的统一方法，我们也可以不通过这个而是自己构建 RequestQueue
• RequestQueue: 负责分发请求到不同的请求队列中
• CacheDispatcher: 处理缓存请求
• NetworkDispatcher: 处理网络请求
• ResponseDelivery: 获取请求后进行处理
• Cache: 缓存接口，具体实现类有 DiskBaseCache
• Network: 网络接口，具体实现类有 BasicNetwork
• HttpStack: 真正执行请求，具体实现类有 HurlStack HttpClientStack
• Request: 封装请求信息并处理回复，具体实现类有 StringRequest JsonRequest
• Response: 封装返回的信息，具体实现类有 NetworkResponse

一些总结

最后再分析一下为什么在 Volley 的 listener 的中可以直接更新UI。
在前面 Volley#newRequestQueue() 中有调用到如下代码

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);

跟进会发现最后调用的是

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

我们上面也提到，最后的 Response 是通过 ResponseDelivery#postResponse() 来分发，而 ExecutorDelivery 是　ResponseDelivery 的实现类，而这个构造函数的实现如下：

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); // 请求最终都会调用 handler.post()，而这个 handler 是上面通过 new Handler(Lopper.getMainLopper()) 得到的
        }
    };
}

请求最终都会调用 handler.post()，而这个 handler 是上面通过 new Handler(Lopper.getMainLopper()) 得到的，所以请求的处理就通过这里分发到主线程中了，也就自然可以更新 UI 了。

最后：
通过对 Volley 源码的分析，可以发现， Volley 框架的拆装性很强，框架默认使用的是 HttpUrlConnection 和 HttpClient 来实现网络请求，如果我们想换成其他，比如okhttp，只要继承 HttpStack 并重写 performRequest()　来处理请求就可以了。对于请求，框架默认提供了 StringRequest 和 JsonRequest，一般情况下这两个是足够用了，但是特别情况下，我们只要继承 Request 并重写 deliverResponse() 和 parseNetworkResponse() 就可以了。
以前自己也有实现过网络框架，相比之下，还是有很多不足，通过阅读源码，还是学到了很多。