Volley源码理解之 一

最近项目需要用到volley,觉得有必要读一下源码，于是乎把这几天的理解写出来，希望能帮助到大家的理解。
volley的具体使用可以参考这里写链接内容。由于太懒就直接借鉴网上的教程啦。

---

Volley类

Volley类主要实现了了一个newRequestQueue方法，在这个方法做了一些初始化工作。

public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);//设置缓存路径
        //这里主要是给sdk9以下的网络设置userAgent参数，
        String userAgent = "volley/0";
        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }

        //一般我们会初始化这个方法newRequestQueue(Context context)，所以在这里会实例化一个stack,这里SDK9以上使用的是
        //HttpURLConnection，以下用的是HttpClient，具体原因可参考http://blog.csdn.net/guolin_blog/article/details/12452307
        //由于现在的手机基本都是9以上，所以只研究HurlStack
        if (stack == null) {
            if (Build.VERSION.SDK_INT >= 9) {
                stack = new HurlStack();
            } else {
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }

        //初始化网络请求
        Network network = new BasicNetwork(stack);

        //这个类是主要实现网络数据和缓存的获取。
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();

        return queue;
    }

HurlStack

现在先对HurlStack进行解读，HurlStack类主要实现了一个 performRequest方法，改方法封装了使用HttpURLConnection访问网络获取结果并且封装到HttpResponse中，看来用HttpURLConnection访问网络，但还是对httpclient念念不忘啊

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
        HttpURLConnection connection = openConnection(parsedUrl, request);
        //添加http header
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }
        /**设置访问方式，如果为post则在addBodyIfExists添加参数
         *  case Method.GET:
                connection.setRequestMethod("GET");
                break;
            case Method.POST:
                connection.setRequestMethod("POST");
                改方法的实现在下面代码
                addBodyIfExists(connection, request);
                break;
         */
        setConnectionParametersForRequest(connection, request);
        /**
         * 下面的方法都是为了将访问结果封装到httpresponse中
         */
        // 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.");
        }
        //封装起始行（‘HTTP/1.1 200 OK’）
        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;
    }

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

 public byte[] getBody() throws AuthFailureError {
        //直接调用getParams()的值作为post请求的参数，默认返回空，所以只要重写getParams就可以往post添加参数了
        Map<String, String> params = getParams();
        if (params != null && params.size() > 0) {
            return encodeParameters(params, getParamsEncoding());
        }
        return null;
    }

BasicNetwork

BasicNetwork 也主要实现了performRequest方法，将数据解析出来存放到NetworkResponse 类中。它接手HurlStack返回的response并封装

public NetworkResponse performRequest(Request<?> request) throws VolleyError {
        long requestStart = SystemClock.elapsedRealtime();
        while (true) {
            HttpResponse httpResponse = null;
            byte[] responseContents = null;
            Map<String, String> responseHeaders = Collections.emptyMap();

                Map<String, String> headers = new HashMap<String, String>();
                addCacheHeaders(headers, request.getCacheEntry());
                //调用HttpStack.performRequest方法获取httpResponse，并解析它
                httpResponse = mHttpStack.performRequest(request, headers);
                StatusLine statusLine = httpResponse.getStatusLine();
                int statusCode = statusLine.getStatusCode();

                //保存所有首部信息
                responseHeaders = convertHeaders(httpResponse.getAllHeaders());
                //304获取本地缓存
                if (statusCode == HttpStatus.SC_NOT_MODIFIED) {

                    Entry entry = request.getCacheEntry();
                    if (entry == null) {
                        return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,
                                responseHeaders, true,
                                SystemClock.elapsedRealtime() - requestStart);
                    }

                    //将返回码，返回主体，返回首部，是否304，接受网络响应时间保存到NetworkResponse类中
                    //304是获取的主体是保存在本地的request.getCacheEntry()
                    return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,
                            entry.responseHeaders, true,
                            SystemClock.elapsedRealtime() - requestStart);
                }


                if (httpResponse.getEntity() != null) {
                  responseContents = entityToBytes(httpResponse.getEntity());
                } else {
                  responseContents = new byte[0];
                }


                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;

                if (statusCode < 200 || statusCode > 299) {
                    throw new IOException();
                }
                //不是304的时候置为false,获取的主体是从服务器获取的httpResponse.getEntity()
                return new NetworkResponse(statusCode, responseContents, responseHeaders, false,
                        SystemClock.elapsedRealtime() - requestStart);
        }

RequestQueue

接下来就是
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
在volley的newRequestQueue中初始化了RequestQueue，在的构造方法如下

DiskBasedCache使用LinkedHashMap定义了一个LRU的缓存方式，具体可以去了解LinkedHashMap。
RequestQueue的构造方法中定义了一个默认threadPoolSize为4的网络请求线程数组，和一个结果执行类ExecutorDelivery
//实例化ExecutorDelivery，参数是主线程的Looper,这样就可以直接在这个实例化的Handler中更新UI,（Handler,Looper,Message的关系）
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;
    }

ResponseDelivery

ExecutorDelivery构造函数如下，初始化mResponsePoster ，后面可直接调用mResponsePoster.execute方法执行Runnable 
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);
            }
        };
    }

该类实现的ResponseDelivery接口的postResponse方法，当调用这个方法时就可以直接在主线程执行Runnable

public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
        //标记已经执行了请求
        request.markDelivered();
        //直接执行封装的ResponseDeliveryRunnable
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
    }
//ResponseDeliveryRunnable线程 执行的时候调用run()
//这个类主要是处理请求结果的时候才会执行的，因为RequestQueue构造方法中实现了，所以就先讲它了
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() {

            //判断网络响应是否成功，成功的话回调deliverResponse，错误的话回调deliverError方法
            if (mResponse.isSuccess()) {
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }

            // 不为空的话执行它
            if (mRunnable != null) {
                mRunnable.run();
            }
       }
    }

RequestQueue初始化之后，调用run()执行它，

//然后启动一个缓存调度线程，四个网络请求线程（默认值为4，threadPoolSize）
//这些线程就会一直循环的获取队列信息，
//启动了这么多线程是要干一场的节奏，所以我们调用Volley.newRequestQueue 方法时，用上单例，才是很好的初始化方式。
public void start() {
        //执行该方法后，调用该方法，首先停止所有下面的线程然后在启动一次，
        stop();  
        // 缓存调度线程
        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();
        }
    }