Volley框架使用与源码解析（二）

在上一篇的讲解中我们基本走了一遍Volley框架的基本请求过程，但是上一篇的请求是在缓存中获取数据的，这篇文章我们着重讲解从网络获取数据的过程。我们在上一篇中知道，Volley框架的两个核心线程是CacheDispatcher线程和NetworkDispatcher线程，前者是关于读取缓存队列的线程，后者是读取网络队列的线程，上篇讲了前者，今天就将后者线程吧。如果忘记了一些概念或者流程就去前面一篇恶补一下吧
直接上NetworkDispatcher的run方法里面的代码

public void run() {
        Process.setThreadPriority(10);
        while(true) {
            Request request;
            while(true) {
                try {
1                   request = (Request)this.mQueue.take();
                    break;
                } catch (InterruptedException var4) {
                    if(this.mQuit) {
                        return;
                    }
                }
            }

            try {
                request.addMarker("network-queue-take");
                if(request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                } else {
                    if(VERSION.SDK_INT >= 14) {
                        TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
                    }

2                   NetworkResponse e = this.mNetwork.performRequest(request);
                    request.addMarker("network-http-complete");
                    if(e.notModified && request.hasHadResponseDelivered()) {
                        request.finish("not-modified");
                    } else {
3                       Response response = request.parseNetworkResponse(e);
                        request.addMarker("network-parse-complete");
                        if(request.shouldCache() && response.cacheEntry != null) {
                            this.mCache.put(request.getCacheKey(), response.cacheEntry);
                            request.addMarker("network-cache-written");
                        }

                        request.markDelivered();
4                       this.mDelivery.postResponse(request, response);
                    }
                }
            } catch (VolleyError var5) {
                this.parseAndDeliverNetworkError(request, var5);
            } catch (Exception var6) {
                VolleyLog.e(var6, "Unhandled exception %s", new Object[]{var6.toString()});
                this.mDelivery.postError(request, new VolleyError(var6));
            }
        }
    }

这段代码很长，其实主要的逻辑方式跟CacheDispatcher差不多，所以主要讲重点地方，其余一些细节的地方只能自己花时间深入看了，因为都不是特别难。看标记1的这句request = (Request)this.mQueue.take();
mQueue是个 BlockingQueue类型，这句其实就是从网络队列里面获得一个reques请求。然后对这个request进行addMark操作，判断这个request是否取消了等等，都是一些细节的处理，我们重点重点重点（重要的事情说三遍）看标记2这句，就是下面这句
NetworkResponse e = this.mNetwork.performRequest(request);
mNetwork是个Network类型，这个实例就是我们在传入RequestQueue的构造函数的network1，看下当时的两句代码当

BasicNetwork network1 = new BasicNetwork((HttpStack)stack);
RequestQueue queue1 = new RequestQueue(new DiskBasedCache(cacheDir), network1);

所以现在我们要对network1的performRequest方法源码进行分析

 BasicNetwork.java
  public NetworkResponse performRequest(Request<?> request) throws VolleyError {
        long requestStart = SystemClock.elapsedRealtime();

        while(true) {
            HttpResponse httpResponse = null;
            Object responseContents = null;
            HashMap responseHeaders = new HashMap();

            try {
                HashMap e = new HashMap();
                this.addCacheHeaders(e, request.getCacheEntry());
1               httpResponse = this.mHttpStack.performRequest(request, e);
                StatusLine statusCode2 = httpResponse.getStatusLine();
                int networkResponse1 = statusCode2.getStatusCode();
                Map responseHeaders1 = convertHeaders(httpResponse.getAllHeaders());
                if(networkResponse1 == 304) {
                    return new NetworkResponse(304, request.getCacheEntry().data, responseHeaders1, true);
                }

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

                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
                this.logSlowRequests(requestLifetime, request, responseContents1, statusCode2);
                if(networkResponse1 >= 200 && networkResponse1 <= 299) {
                    return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
                }

                throw new IOException();
            } catch (SocketTimeoutException var12) {
                attemptRetryOnException("socket", request, new TimeoutError());
            } catch (ConnectTimeoutException var13) {
                attemptRetryOnException("connection", request, new TimeoutError());
            } catch (MalformedURLException var14) {
                throw new RuntimeException("Bad URL " + request.getUrl(), var14);
            } catch (IOException var15) {
                boolean statusCode = false;
                NetworkResponse networkResponse = null;
                if(httpResponse == null) {
                    throw new NoConnectionError(var15);
                }

                int statusCode1 = httpResponse.getStatusLine().getStatusCode();
                VolleyLog.e("Unexpected response code %d for %s", new Object[]{Integer.valueOf(statusCode1), request.getUrl()});
                if(responseContents == null) {
                    throw new NetworkError(networkResponse);
                }

                networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
                if(statusCode1 != 401 && statusCode1 != 403) {
                    throw new ServerError(networkResponse);
                }

                attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));
            }
        }
    }

这段代码很长，我们还是着重看网络请求的处理过程，network其实并没有真正的去做网络请求，我们知道在java api里面有个HttpURLConnection这个类对吧，这个类会做网络请求的事情，这里也是，Volley框架里面也是用到了HttpURLConnection和HttpClient这两个类，至于用哪个类是根据sdk版本来决定的，这两个实例就是在Volley这个类的newRequestQueue这个方法里面生成的，忘了的可以回去看看。我们看标记1的这句
httpResponse = this.mHttpStack.performRequest(request, e);
e是个Hashmap类型，如果为空就说明本地没有该request的response，如果不为空就说明本地的response已经过期了需要重新去网络请求，设置一些header的信息。mHttpStack是个HurlStack类型（这里我们暂时以这个类型做说明，因为有可能是HttpClientStack类型，逻辑功能完全一样，没必要纠结）我们来看看HurlStack的performRequest方法

   public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError {
        String url = request.getUrl();
        HashMap map = new HashMap();
        map.putAll(request.getHeaders());
        map.putAll(additionalHeaders);
        if(this.mUrlRewriter != null) {
            String parsedUrl = this.mUrlRewriter.rewriteUrl(url);
            if(parsedUrl == null) {
                throw new IOException("URL blocked by rewriter: " + url);
            }

            url = parsedUrl;
        }

        URL parsedUrl1 = new URL(url);
1        HttpURLConnection connection = this.openConnection(parsedUrl1, request);
        Iterator responseCode = map.keySet().iterator();

        while(responseCode.hasNext()) {
            String protocolVersion = (String)responseCode.next();
            connection.addRequestProperty(protocolVersion, (String)map.get(protocolVersion));
        }

        setConnectionParametersForRequest(connection, request);
        ProtocolVersion protocolVersion1 = new ProtocolVersion("HTTP", 1, 1);
        int responseCode1 = connection.getResponseCode();
        if(responseCode1 == -1) {
            throw new IOException("Could not retrieve response code from HttpUrlConnection.");
        } else {
            BasicStatusLine responseStatus = new BasicStatusLine(protocolVersion1, connection.getResponseCode(), connection.getResponseMessage());
            BasicHttpResponse response = new BasicHttpResponse(responseStatus);
            response.setEntity(entityFromConnection(connection));
            Iterator var12 = connection.getHeaderFields().entrySet().iterator();

            while(var12.hasNext()) {
                Entry header = (Entry)var12.next();
                if(header.getKey() != null) {
                    BasicHeader h = new BasicHeader((String)header.getKey(), (String)((List)header.getValue()).get(0));
                    response.addHeader(h);
                }
            }

            return response;
        }
    }

这段代码主要就是HttpURLConnection请求，代码标记1HttpURLConnection connection = this.openConnection(parsedUrl1, request);最终会调用到(HttpURLConnection)url.openConnection();这句，并且会设置一些连接属性，获得connection之后就会添加请求header信息，然后看这句
response.setEntity(entityFromConnection(connection));
我们再看下entityFromConnection(connection)这个方法

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

很明显这个方法里面就是保存了我们所需要的响应数据，看到这句entity.setContent(inputStream);没，说明我们存的是connection的输入流，这里并没有真正的已经获取到数据了，这其实有好处的，以后如果我们要获取数据应该是通过这个输入流来获取的，还存了其他一些header信息，然后将entity封装到response里面返回，这里我们通过网络请求得到的数据成功返回了，我们回头再看BasicNetwork的performRequest方法的 httpResponse = this.mHttpStack.performRequest(request, e);这句，就是将刚才通过HttpURLConnection得到的response返回给httpResponse，然后会一步一步执行到responseContents1 = this.entityToBytes(httpResponse.getEntity());这句，这里就是会去获取之前connection的inputStream输入流，根据输入流来获取byte[]数组，responseContents1 是个byte[]类型，然后将这个byte[]和其他一些信息封装到NetworkResponse这个类型中返回该类型的实例，具体可以细细读BasicNetwork的performRequest方法，接下来我们再回到NetworkDispatcher的run方法的 NetworkResponse e = this.mNetwork.performRequest(request);这句，我们得到response之后就要做解析成我们所要的数据了， Response response = request.parseNetworkResponse(e);比如有String类型或者Image类型或者JSON类型甚至可以自定义成XML类型等等，同时会将数据封装在Entry这个类型里面，这个类型前面一篇讲过的，然后会根据这个request是否需要缓存来对Entry进行缓存 this.mCache.put(request.getCacheKey(), response.cacheEntry);这句就是将Entry里面的数据包括主要的信息和一些Header信息写到cache的file里面，一旦缓存完了就要执行repsonse的派发了 this.mDelivery.postResponse(request, response);这个应该很熟悉了，上篇讲过的，方式跟cache的消息派发是一样的，都是回调主线程的request的Response.Listener和Response.ErrorListener，这里就不贴源码了，上篇说过的，忘了可以回看下吧。好了，关于网络请求的部分讲完了，关于Volley框架的核心功能部分基本就讲完了，其实讲的也是非常重要的主干部分，如果有时间有精力可以再去看看其他部分的细节，比如Volley框架关于图片缓存技术的自定义，Volley框架实现自定义的Request请求，Volley框架将网络层的HttpStack换成Okhttp框架，Volley里面的byte数组的缓存池等等，如果有时间和精力我再去写写这些方面的东西。