Android之记录并研究Volley框架中知识点

转载请标明出处:
http://blog.csdn.net/hai_qing_xu_kong/article/details/50916258
本文出自:【顾林海的博客】

##前言

在上一遍《对Volley网络框架的一些理解》文章中记录一些自己刚看Volley源码时的一些内容,大体知道了从创建请求队列、添加请求到请求队列、最后请求数据的一个流程,内容比较杂乱,这边文章是今天重新看Volley源码时的一些笔记,记录的内容不是笔记系统(最主要的是对自己思路的一个总结,方便以后回头看Volley时,对当时一些思路的纠正),还望多多海涵,有不对的地方欢迎指出。

##第一次源码分析
查看Volley这个类的源码:

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.volley.toolbox;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.net.http.AndroidHttpClient;
import android.os.Build;

import com.android.volley.Network;
import com.android.volley.RequestQueue;

import java.io.File;

public class Volley {

    /** Default on-disk cache directory. */
    private static final String DEFAULT_CACHE_DIR = "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);
    }
}

一般我们通过newRequest(Context context)方法来创建我们的请求队列的,但请看上面这个方法内部是调用了newRequestQueue(context, null),第二个参数就是我们的实现HttpStack这个接口的类,上一篇文章也说过了在Volley中,http的处理请求,默认 Android2.3 及以上基于 HttpURLConnection的 HurlStack,2.3 以下基于 HttpClient 的 HttpClientStack,也就是说这两个类都实现了HttpStack,先看看基于HttpURLConnection的 HurlStack这个类,HurlStack实现了HttpStack接口并实现了performRequest这个方法:

HurlStack类:
	@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;
    }

这里面的Request就是我们的StringRequest、JsonRequest、ImageReques以及我们自定义的Request,比如:

StringRequest stringRequest = new StringRequest(Request.Method.GET,
                url, new Response.Listener<String>() {

                    @Override
                    public void onResponse(String response) {

                    }
                }, new Response.ErrorListener() {

                    @Override
                    public void onErrorResponse(VolleyError error) {

                    }
     });

接着我们主要看performRequest 这个方法中到底做了什么,这里要搞明白方法中的两个参数分别代表什么含义,第一个参数之前已经说过了是我们通过请求队列add进去的Request,第二个参数additionalHeaders是存放的缓存的请求头,这部分会在后面提到。

String url = request.getUrl();

通过request获取我们的请求地址。

HashMap<String, String> map = new HashMap<String, String>();
map.putAll(request.getHeaders());
map.putAll(additionalHeaders);

创建HashMap存放请求头的信息。

if (mUrlRewriter != null) {
            String rewritten = mUrlRewriter.rewriteUrl(url);
            if (rewritten == null) {
                throw new IOException("URL blocked by rewriter: " + url);
            }
            url = rewritten;
 }

通过rewriteUrl获取一个URL,并赋值给url,这里面的mUrlRewriter为空,暂时可以不用管它。

URL parsedUrl = new URL(url);
HttpURLConnection connection = openConnection(parsedUrl, request);

通过调用openConnection方法创建HttpURLConnection对象:

private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
        HttpURLConnection connection = createConnection(url);

        int timeoutMs = request.getTimeoutMs();
        connection.setConnectTimeout(timeoutMs);
        connection.setReadTimeout(timeoutMs);
        connection.setUseCaches(false);
        connection.setDoInput(true);

        // use caller-provided custom SslSocketFactory, if any, for HTTPS
        if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
            ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
        }

        return connection;
 }

 protected HttpURLConnection createConnection(URL url) throws IOException {
        return (HttpURLConnection) url.openConnection();
  }

上面代码很简单,创建HttpURLConnection对象,并配置连接超时时间、读超时时间、是否设置缓存、通过设置setDoInput为tue获取输入流,接着判断我们请求接口是否以"https"开头,并判断是否使用了证书的HTTPS连接方式。

SSL(Secure Sockets Layer 安全套接层),及其继任者传输层安全(Transport Layer Security,TLS)是为网络通信提供安全及数据完整性的一种安全协议。TLS与SSL在传输层对网络连接进行加密。SSL/TLS协议位于HTTP协议与传输层协议之间,采用公钥技术,为两个应用间的通讯提供加密、完整性校验以及身份认证。SSL协议提供了三个功能:
使用公钥证书对双端进行认证(一般仅进行服务器认证,客户端认证为可选)
通信加密(Confidentiality)
数据完整性检查(Data integrity)

继续看performRequest方法:

for (String headerName : map.keySet()) {
    connection.addRequestProperty(headerName, map.get(headerName));
}

添加http信息头。

setConnectionParametersForRequest(connection, request);

static void setConnectionParametersForRequest(HttpURLConnection connection,
            Request<?> request) throws IOException, AuthFailureError {
        switch (request.getMethod()) {
            case Method.DEPRECATED_GET_OR_POST:
                // This is the deprecated way that needs to be handled for backwards compatibility.
                // If the request's post body is null, then the assumption is that the request is
                // GET.  Otherwise, it is assumed that the request is a POST.
                byte[] postBody = request.getPostBody();
                if (postBody != null) {
                    // Prepare output. There is no need to set Content-Length explicitly,
                    // since this is handled by HttpURLConnection using the size of the prepared
                    // output stream.
                    connection.setDoOutput(true);
                    connection.setRequestMethod("POST");
                    connection.addRequestProperty(HEADER_CONTENT_TYPE,
                            request.getPostBodyContentType());
                    DataOutputStream out = new DataOutputStream(connection.getOutputStream());
                    out.write(postBody);
                    out.close();
                }
                break;
            case Method.GET:
                // Not necessary to set the request method because connection defaults to GET but
                // being explicit here.
                connection.setRequestMethod("GET");
                break;
            case Method.DELETE:
                connection.setRequestMethod("DELETE");
                break;
            case Method.POST:
                connection.setRequestMethod("POST");
                addBodyIfExists(connection, request);
                break;
            case Method.PUT:
                connection.setRequestMethod("PUT");
                addBodyIfExists(connection, request);
                break;
            default:
                throw new IllegalStateException("Unknown method type.");
        }
 }

private static final String HEADER_CONTENT_TYPE = "Content-Type";

private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
            throws IOException, AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            connection.setDoOutput(true);
            connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(body);
            out.close();
        }
}

这里面的代码也比较简单,根据我们创建Request时定义的请求方式,进行相应的配置。这里面关注一下如果是PUT方式,会调用addBodyIfExists方法,在这个方法中通过设置setDoOutput为true,来获取输出流并设置了实体头(Content-Type 响应的对象的类型),以此向服务器发送数据。

HTTP的头域包括通用头、请求头、响应头和实体头四个部分。每个头域由一个域名,冒号(:)和域值三部分组成(说白了就是键值对)。
通用头:是客户端和服务器都可以使用的头部,可以在客户端、服务器和其他应用程序之间提供一些非常有用的通用功能,如Date头部。
请求头:是请求报文特有的,它们为服务器提供了一些额外信息,比如客户端希望接收什么类型的数据,如Accept头部。
响应头:便于客户端提供信息,比如,客服端在与哪种类型的服务器进行交互,如Server头部。
实体头:指的是用于应对实体主体部分的头部,比如,可以用实体头部来说明实体主体部分的数据类型,如Content-Type头部。

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

 private static HttpEntity entityFromConnection(HttpURLConnection connection) {
        BasicHttpEntity entity = new BasicHttpEntity();
        InputStream inputStream;
        try {
            inputStream = connection.getInputStream();
        } catch (IOException ioe) {
            inputStream = connection.getErrorStream();
        }
        entity.setContent(inputStream);
        entity.setContentLength(connection.getContentLength());
        entity.setContentEncoding(connection.getContentEncoding());
        entity.setContentType(connection.getContentType());
        return entity;
    }

以上代码就是performRequest最后的部分了,这段代码主要是将请求的结果进行相应的初始化,重点关注entityFromConnection,获取输入流、数据大小、网络编码并通过for循环获取头信息,最好将这些信息封装在BasicHttpResponse 对象中。
总结一下HurlStack中performRequest方法通过HttpURLConnection进行网络连接,并获取返回的网络数据。

以上是HurlStack的performRequest方法,相应的HttpClientStack中的performRequest方法也是进行了一系列的网络请求。
知道了HttpStack这个接口中的performRequest方法的用处后,我们就得找找什么进行网络请求的,这时回到newRequestQueue(Context context, HttpStack stack)方法中,看看这个stack给谁了

这里写图片描述

这个stack在通过实例化BasicNetwork时传递给了BasicNetwork对象中,接着让我们扒开BasicNetwork源码看看。

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

public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
        mHttpStack = httpStack;
        mPool = pool;
    }

最终stack赋值给了mHttpStack,那这个mHttpStack在哪里被用到的,继续看BasicNetwork,它实现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;
}

于是乎,在BasicNetwork中的performRequest中找到了我们mHttpStack,也就是说在performRequest方法中调用HttpStack进行网络的请求处理,
方法返回的是NetworkResponse对象,NetworkResponse保存返回以字节形式的数据。那这里的 performRequest方法又是在什么时候调用的呢?

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

通过上面一步一步的查找,创建请求队列时进行了一些列的初始化,到这里还是没有看到哪里调用网络请求的操作,最后我们查看

queue.start();

这里写图片描述

在start方法中我们终于找到了Network,接着查看NetworkDispatcher:

这里写图片描述

NetworkDispatcher是一个线程,用于调度处理网络的请求。启动后会不断从网络请求队列中取请求处理,队列为空则等待,请求处理结束则将结果传递给ResponseDelivery去执行后续处理,并判断结果是否要进行缓存。因此只要找到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;
                }

                // Tag the request (if API >= 14)
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                    TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
                }

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

从上面的代码中找到这么几条语句:

 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中的parseNetworkResponse方法获取返回的Response。

这里写图片描述

最终结果转换为可被ResponseDelivery处理的NetworkResponse,目前只有基于ExecutorDelivery的 handler 对应线程内进行分发。

找到ExecutorDelivery中的handler分发事件源码:

@Override
    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));
    }

通过execute进行任务分发ResponseDeliveryRunnable实现了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;
            }

            // 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的deliverResponse方法,查看StringRequest方法中的deliverResponse方法:

@Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }

最后通过接口回调将从网络获取的数据返回给客户端。

##第二次源码分析

Volley文件:
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;
}

对此方法解析:

File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

通过context.getCacheDir() 获取 /data/data//cache目录下文件叫volley的文件,DEFAULT_CACHE_DIR的值是"volley"。

String userAgent = "volley/0";
 try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }

这个userAgent是传给服务器的,在创建HttpClient之前(SDK版本小于9),packageName获取到项目包名,info.versionCode获取版本号,userAgent为 :项目包名/项目版本号。
userAgent在获取包名异常时会使用默认的"volley/0",否则为“包名/版本号”。

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

一般情况下stack为null,这时就会去判断SDK的版本,如果是大于等于9,使用HttpURLConnection;否则使用HttpClient。

使用HttpClient时通过AndroidHttpClient的静态方法newInstance创建。

查看AndroidHttpClient源码:

public final class AndroidHttpClient implements HttpClient {
}

HttpClient其实是一个接口,HttpClient封装了对象需要执行的Http请求、身份验证、连接管理和其它特性, 从文档上看,HttpClient有三个已知的实现类分别是:AbstractHttpClient, AndroidHttpClient, DefaultHttpClient,会发现有一个专门为Android应用准备的实现类AndroidHttpClient,当然使用常规的DefaultHttpClient也可以实现功能。
从两个类包所有在位置就可以看出区别,AndroidHttpClient定义在android.net.http.AndroidHttpClient包下,属于Android原生的http访问,而DefaultHttpClient定义在org.apache.http.impl.client.DefaultHttpClient包下,属于对apche项目的支持。而AndroidHttpClient没有公开的构造函数,只能通过静态方法newInstance()方法来获得AndroidHttpClient对象。

AndroidHttpClient对于DefaultHttpClient做了一些改进,使其更适用于Android项目:

  • 关掉过期检查,自连接可以打破所有的时间限制。
  • 可以设置ConnectionTimeOut(连接超时)和SoTimeout(读取数据超时)。
  • 关掉重定向。
  • 使用一个Session缓冲用于SSL Sockets。
  • 如果服务器支持,使用gzip压缩方式用于在服务端和客户端传递的数据。
  • 默认情况下不保留Cookie。

简单来说,用HttpClient发送请求、接收响应都很简单,只需要几个步骤即可:

  • 创建HttpClient对象。
  • 创建对应的发送请求的对象,如果需要发送GET请求,则创建HttpGet对象,如果需要发送POST请求,则创建HttpPost对象。
  • 对于发送请求的参数,GET和POST使用的方式不同,GET方式可以使用拼接字符串的方式,把参数拼接在URL结尾;POST方式需要使用setEntity(HttpEntity entity)方法来设置请求参数。
  • 调用HttpClient对象的execute(HttpUriRequest request)发送请求,执行该方法返回一个HttpResponse对象。
  • 调用HttpResponse的对应方法获取服务器的响应头、响应内容等。
Network network = new BasicNetwork(stack);

实例化BasicNetwork对象,将stack通过构造器传递过去。

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

new ByteArrayPool(DEFAULT_POOL_SIZE),实例化ByteArrayPool 类并指定了最大缓存区的大小,DEFAULT_POOL_SIZE值是4096。

public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
        mHttpStack = httpStack;
        mPool = pool;
    }

最后将stack和pool分别赋值给mHttpStack和mPool。

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

实例化RequestQueue这个类,通过RequestQueue构造器传递了DiskBasedCache对象和network(BasicNetwork对象),在实例化DiskBasedCache这个类时指定了缓存的根目录也就是cacheDir,这个值在上面已经提到过。

public DiskBasedCache(File rootDirectory) {
        this(rootDirectory, DEFAULT_DISK_USAGE_BYTES);
 }

 public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {
        mRootDirectory = rootDirectory;
        mMaxCacheSizeInBytes = maxCacheSizeInBytes;
  }

指定了最大缓存数为DEFAULT_DISK_USAGE_BYTES,默认5MB。mRootDirectory指定了缓存根目录,mMaxCacheSizeInBytes指定了缓存的大小。

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

    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;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

创建RequestQueue对象时进行了相应的初始化(缓冲、网络请求、网络请求调度线程数、请求结果的分发)。

到这里,整理下上面的逻辑:

  1. 根据版本号创建了HurlStack或HttpClientStack对象为stack。

  2. 创建了BasicNetwork对象network,并初始化了BasicNetwork内的属性值:
    -mHttpStack:第一步根据版本号创建的访问网络的种类。
    -mPool :实例化ByteArrayPool类,并指定了ByteArrayPool中mSizeLimit缓冲区为4096。

  3. 创建我们的请求队列RequestQueue对象queue,实例化对本地缓冲和网络类型进行初始化:
    mCache:指定了磁盘缓冲的目录和大小。
    mNetwork:BasicNetwork网络请求
    mDispatchers:创建4个网络请求调度的线程
    mDelivery:指定返回请求结果的分发。

最后开始请求:

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

在开始请求时先确保正在执行的请求调度线程是否已经终止掉,查看stop方法:

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

mCacheDispatcher和mDispatchers分别是缓冲调度线程和网络调度线程,这里面分别将缓冲和网络的调度线程终止。

stop方法后:

mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);

创建缓冲调度线程,mCacheQueue是缓冲的请求队列,mNetworkQueue是网络的请求队列,mCache是缓冲,mDelivery是用于请求结果的分发。

public CacheDispatcher(
            BlockingQueue<Request> cacheQueue, BlockingQueue<Request> networkQueue,
            Cache cache, ResponseDelivery delivery) {
        mCacheQueue = cacheQueue;
        mNetworkQueue = networkQueue;
        mCache = cache;
        mDelivery = delivery;
    }

接着mCacheDispatcher.start()进行了缓存线程开启,执行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;
            }
        }
    }

 if (DEBUG) VolleyLog.v("start new dispatcher");
 打印日志信息。
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
设置线程优先级为后台,这样当多个线程并发后很多无关紧要的线程分配的CPU时间将会减少,有利于主线程的处理

mCache.initialize();
缓存目录的初始化。
查看DiskBasedCache中的initialize方法:
    @Override
    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) {
            FileInputStream fis = null;
            try {
                fis = 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) { }
            }
        }
    }
initialize方法中判断缓存的根目录是否存在,不存在创建;否则的话:
 File[] files = mRootDirectory.listFiles();
获取目录下的文件。
        for (File file : files) {
            FileInputStream fis = null;
            try {
                fis = 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) { }
            }
        }
遍历更目录下的文件,进行读取,读取是文件存在但出现异常将文件删除,读取时调用DiskBasedCache内部类CacheHeader中的readHeader方法:

        public static CacheHeader readHeader(InputStream is) throws IOException {
            CacheHeader entry = new CacheHeader();
            int magic = readInt(is);
            if (magic != CACHE_MAGIC) {
                // don't bother deleting, it'll get pruned eventually
                throw new IOException();
            }
            entry.key = readString(is);
            entry.etag = readString(is);
            if (entry.etag.equals("")) {
                entry.etag = null;
            }
            entry.serverDate = readLong(is);
            entry.ttl = readLong(is);
            entry.softTtl = readLong(is);
            entry.responseHeaders = readStringStringMap(is);
            return entry;
        }

创建CacheHeader对象,并将读取到的数据赋值给CacheHeader中的Filed。

private void putEntry(String key, CacheHeader entry) {
        if (!mEntries.containsKey(key)) {
            mTotalSize += entry.size;
        } else {
            CacheHeader oldEntry = mEntries.get(key);
            mTotalSize += (entry.size - oldEntry.size);
        }
        mEntries.put(key, entry);
   }
读取完缓存根目录中的某个文件后,进行统计,如果之前没有缓存过这个数据,就进行缓存大小的累加mTotalSize,否则新的累加上新旧缓存文件的差值。最后将相应的缓存文件以键值对保存起来。

继续回到run方法中,以下是了无限循环操作:

final Request request = mCacheQueue.take();
   request.addMarker("cache-queue-take");

从缓存队列中取出我们的Request,并记录线程的事件日志。

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

如果这个请求已经取消,跳过这次循环,继续取出请求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;
    }

取出来的数据为空,跳过这次循环。

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");

取出缓存数据Response 并回调给Request中的parseNetworkResponse方法。

  if (!entry.refreshNeeded()) {
                    mDelivery.postResponse(request, response);
                } else {
                    request.addMarker("cache-hit-refresh-needed");
                    request.setCacheEntry(entry);

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

是否进行数据刷新,不需要直接通过ExecutorDelivery进行结果的分发。否则的话添加到网络请求队列中。
到这里为止缓存调度线程已经开启,接着看下面的这条语句:

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

依次执行网络调度线程,这里面是默认4个线程,查看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;
                }

                // Tag the request (if API >= 14)
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                    TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
                }

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

Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
设置线程优先级为后台,这样当多个线程并发后很多无关紧要的线程分配的CPU时间将会减少,有利于主线程的处理
request = mQueue.take();
老样子通过无限循环从网络请求队列中取出我们定义的Request。
如果出现异常情况下执行:
if (mQuit) {
        return;
 }

mQuit用于退出循环的标志位,在start方法中的第一步执行stop时,就将mQuit置为true。

if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
 }

如果这个请求已经取消,跳过这次循环,继续取出请求Request 。

// Tag the request (if API >= 14)
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                    TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
                }

对网络连接打上tag。

NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");

进行网络请求,并获取请求结果。

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

服务器返回304,并且我们已经提供了响应,这是跳过本次循环。

Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

拿到请求结果,并回调给Request中的parseNetworkResponse方法。

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

进行缓存。

request.markDelivered();
mDelivery.postResponse(request, response);

最后通过ExecutorDelivery进行结果的分发。

##写在最后的话

写到这里基本已经结束,Volley的源码很值得大家研究,目前本人只是粗略的研究了下,在业余时间还是会继续研究。

©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页