Android-Volley源码分析

原创 2015年11月19日 23:27:57
       在上一篇文章Android-使用Volley 连接网络中,学习了简单使用Volley连接网络并获取数据,今天就来学习一下Volley的源码。毕竟刚开始接触Volley的时候,谁都难免会对其实现过程有所迷惑,我以自己刚接触Volley时心中的几点疑惑为例:
1)Volley 是靠什么去连接网络的?
2)Volley要连接网络,就需要异步类的操作,Volley是如何处理这步的?
3)Volley的流程是如何跑的?

在阅读源代码之前,可以先观看一下Android官方文档提供的一张图(如下图):
    
       先可以按照图上显示的内容,从字面上了解Volley的流程:首先是Request在主线程被添加到一个优先顺序的队列,然后交给了CacheDispatcher,CacheDispatcher从字面上意思猜测是个缓存调度器,先不用管它到底干了什么,但是可以肯定它对Request做了处理,如果处理结果存在,就从Cache中请求数据并解析,再将得到的结果返回给主线程,让主线程解析去解析这个结果,如果处理结果不存在,就将Request丢给NetworkDispatcher(也是一个调度器),NetworkDispatcher就处理这个request,并把结果返回给主线程,让主线程去解析这个结果,根据图了解的简单流程就这样,现在就带着这个简单的流程和上面的问题去看Volley源代码:

 -->程序获得RequestQueue的时候,Volley源代码实现了一些什么:
/**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @param stack An {@link HttpStack} to use for the network, or null for default.
     * @return A started {@link RequestQueue} instance.
     */
    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 {
                // 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 = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();
        return queue;
    }

    /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @return A started {@link RequestQueue} instance.
     */
    public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, null);
    }
       从源代码中可以看出程序获得RequestQueue,最终执行的方法是newRequestQueue(Context contextHttpStack stack),其内部第一步就为高速缓存创建了一个file 。后面还选择stack,这个stack是HurlStack,在Android-HttpClient连接网络获取数据 中介绍了Android当前版本中HttpClient的使用情况,大多选择都是HttpURLConnection,而这里对于SDK 版本高于9都是选择HurlStack,HurlStack也是通过HttpURLConnection来实现访问网络的,如源代码:
@Override
    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);
        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;
    }
  看到这个就解除了第一个疑惑,Volley通过HttpURLConnection访问网络。
  在得到RequestQueue以后,就启动这个RequestQueue。RequestQueue的start()方法又做了那些操作:  
  /**
     * 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();
        }
    }
   /**
     * Stops the cache and network dispatchers.
     */
    public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }
        start()方法第一步就是先stop cache 和 network两个调度器,然后再重新创建这两个调度器。而这两个调度器都是继承于Thread,是两个线程。并且在它们的run()方法中设置了后台运行属性:    
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
 代码看到这里就解除了第二个疑惑。此时queue也start了,在写代码的时候在queue被start之后,就要把request添加到queue中,如:mRequestQueue.add(jsObjRequest)。

->RequestQueue中的add()方法实现了那些操作(这个一步也是流程图上的第一步):
/**
     * Adds a Request to the dispatch queue.
     * @param request The request to service
     * @return The passed-in 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);
        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;
        }
    }
      在代码中可以看到一个if语句的判断(!request.shouldCache()),判断request是否缓存,shouldCache默认值为true,但是可以通过下面方法来改变它的值:  
  /**
     * Set whether or not responses to this request should be cached.
     *
     * @return This Request object to allow for chaining.
     */
    public final Request<?> setShouldCache(boolean shouldCache) {
        mShouldCache = shouldCache;
        return this;
    }
  默认是需要缓存的,就通过mCacheQueue.add(request)将request加入到mCacheQueue队列,如果不需要缓存就会通过mNetworkQueue.add(request)将request加入到network队列。
  request被add到mCacheQueue以后,由于之前在RequestQueue的start()方法中,将mCacheQueue传给了CacheDispatcher,mCacheDispatcher.start()之后,就会执行CacheDispatcher重写于Thread类的run()方法: 
  @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.
                final Request<?> request = mCacheQueue.take();
                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.
                    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;
            }
        }
    }
  这个run()方法里边有个while(true)循环,是一个无限循环,只要cache线程不停止,就不停的从缓存队列中取出请求结果,获得请求结果之后就通过mDelivery.postResponse()方法,将结果传递到主线程去处理。为什么说这里传递到了主线程呢?在前面获得RequestQueue对象的时候,代码是这么实现的: 
   ...
    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
    queue.start();
    return queue;
    ...
其实new RequestQueue对象最终调用的方法是:  
   /**
     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
     *
     * @param cache A Cache to use for persisting responses to disk
     * @param network A Network interface for performing HTTP requests
     * @param threadPoolSize Number of network dispatcher threads to create
     */
    public RequestQueue(Cache cache, Network network, int threadPoolSize) {
        this(cache, network, threadPoolSize,
                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
    }
  其中threadPoolSize = 4,而Looper.getMainLooper()就相当于主线程。这样在cache线程中获得结果最终传递给了主线程,让主线程来解析这个response,再回到CacheDispatcher的run()方法中,从缓存队列不一定能取出结果,即使取出了结果也可能不是最新的,这个时候就需要从新从网络获取数据,run()方法中有这么两个判断:                    
            // 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;
                }
    源码看到此处,request总共有几种情况会被加入到network队列?我总结的是总共有三种情况request被加入到network队列,第一次是判断request是否需要缓存,不要需要缓存,request会被加入到network队列,后面两种情况如上面所述的两种情况了(流程图上第二步在这里就完成)。
    经过上面的分析,cache线程对request的处理就完成了,但是由于上面所说的三种情况,request会被加入到network队列,下面就继续分析network,同样看看NetworkDispatcher的run()方法:    
@Override
    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'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) {
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                mDelivery.postError(request, new VolleyError(e));
            }
        }
    }
    从run()方法中可见,network线程会去执行network request:        
// Perform the network request.
    NetworkResponse networkResponse = mNetwork.performRequest(request);
    先来看看mNetwork是个什么东东,mNetwork是Network,它从newRequestQueue的时候就被创建:    
Network network = new BasicNetwork(stack);
   
 /**
     * @param httpStack HTTP stack to be used
     */
    public BasicNetwork(HttpStack httpStack) {
        // If a pool isn't passed in, then build a small default pool that will give us a lot of
        // benefit and not use too much memory.
        this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE));
    }
    /**
     * @param httpStack HTTP stack to be used
     * @param pool a buffer pool that improves GC performance in copy operations
     */
    public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
        mHttpStack = httpStack;
        mPool = pool;
    }
    所以mNetwork实际上是new了一个BasicNetwork对象,而BasicNetwork实现了接口Network。其performRequest方法如下:
     @Override
    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 (SocketTimeoutException e) {
                attemptRetryOnException("socket", request, new TimeoutError());
            } catch (ConnectTimeoutException e) {
                attemptRetryOnException("connection", request, new TimeoutError());
            } catch (MalformedURLException e) {
                throw new RuntimeException("Bad URL " + request.getUrl(), e);
            } catch (IOException e) {
                int statusCode = 0;
                NetworkResponse networkResponse = null;
                if (httpResponse != null) {
                    statusCode = httpResponse.getStatusLine().getStatusCode();
                } else {
                    throw new NoConnectionError(e);
                }
                VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
                if (responseContents != null) {
                    networkResponse = new NetworkResponse(statusCode, responseContents,
                            responseHeaders, false);
                    if (statusCode == HttpStatus.SC_UNAUTHORIZED ||
                            statusCode == HttpStatus.SC_FORBIDDEN) {
                        attemptRetryOnException("auth",
                                request, new AuthFailureError(networkResponse));
                    } else {
                        // TODO: Only throw ServerError for 5xx status codes.
                        throw new ServerError(networkResponse);
                    }
                } else {
                    throw new NetworkError(networkResponse);
                }
            }
        }
    }
在此方法中会去连接网络:   
httpResponse = mHttpStack.performRequest(request, headers);
  经过前面的分析mHttpStack是stack,而对于SDK高于9的版本 stack是HurlStack类的一个对象,HurlStack又实现了HttpStack接口,所以mHttpStack.performRequest(request, headers)执行的是HurlStack中的performRequest()方法,此方法最终使用HttpURLConnection来连接网络并获取网络数据,代码在前面贴了。至此,Volley连接网络的流程也显出端倪了。
回到network调度器的run()方法中,经过上面根据request从网络获取到数据(response),接下来就会解析response,把解析的结果写入cache(如果可以),最后返回给主线程。
    ...
// 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);
  ...

  至此,整个流程就分析完了,回想前面的流程图,根据这些源码就显得清晰不少了。  
    
    
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Android-Volley源码分析

Volley是Google推出的Android异步网络调用框架和图片加载框架。在Google I/O 2013大会上发布。 名字由来:a burst or emission of many thing...
  • grumoon
  • grumoon
  • 2014年10月28日 15:22
  • 601

[Android] Volley源码分析(一)体系结构

Volley:google出的一个用于异步处理的框架。由于本身的易用性和良好的

[Android]Volley源码分析(四)请求队列

在[Android]Volley源码分析(一)概述中,我们看到了Volley通过调研RequestQueue的start()方法启动了一个请求队列,下面我们通过代码看看具体是如何实现的:...
  • hunkpei
  • hunkpei
  • 2014年09月23日 16:30
  • 534

【Android框架】volley源码分析

网络请求是Android最常见的功能模块,一开始我们有JDK中自带的网络请求框架HttpURLConnection,这是JDK1.1中就开始有的,后面有了Apache的HttpClient,它提供了更...

android-----Volley框架源码分析

作为Google的亲儿子,Volley框架从诞生之日起就受到极大推崇,他简单且适用于频繁的网络操作环境中,并且是适用于异步的环境下,但是对于上传文件或者想要post一些较大数据的场合,显然他是束手无策...

Android Volley源码分析(二) 核心功能解析

核心功能的介绍       Volley.java 这个和 Volley 框架同名的类,工具类,作用是构建一个可用于添加网络请求的RequestQueue对象。        1) 主要函数 pub...

android-----Volley框架使用ImageLoader加载图片源码分析

上一篇我们分析了Volley框架的源码,知道了使用Volley框架的三个步骤,如果你对此还不是很熟,希望能看看上一篇博文:android-----Volley框架源码分析,这篇我们将首先使用Volle...

[Android]Volley源码分析(六)图片请求ImageRequest

Volle
  • hunkpei
  • hunkpei
  • 2014年09月26日 15:09
  • 599

Android网络框架-Volley(三) CacheDispatcher和NetworkDispatcher源码分析

在Android网络框架-Volley(一) 工作原理分析 中的流程图中我们知道Volley工作是有三个线程的:主线程、缓存线程和网络线程。这些线程的工作是建立在RequestQueue上的,上一篇...

Android中Volley的使用及部分源码分析

本篇博客主要记录一下Volley的基本用法,为之后分析Volley源码做一下铺垫。
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android-Volley源码分析
举报原因:
原因补充:

(最多只允许输入30个字)