Volley源码学习（二）：网络请求处理，HurlStack类，BasicNetwork类，ByteArrayPool，PoolingByteArrayOutputStream

一.源码解析

volley用于处理网络请求的HurlStack类和BasicNetwork类，继承HttpStack接口

1.接口HttpStack，定义了方法HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)，处理网络请求，获得HttpResponse。

2.类HurlStack:使用httpconnection处理网络请求

主要方法：

方法：performRequest(Request<?> request, Map<String, String> additionalHeaders)

逻辑流程：获得url,new map添加request里的headers和additionalHeaders→有mUrlRewriter就重写url→获得connection = openConnection(parsedUrl, request);→遍历map,connection.addRequestProperty，为connection添加 headers.→获得responseCode并new responseStatus→response = new BasicHttpResponse(responseStatus);→ response.setEntity，设置entity→遍历，将connection的headers添加到response里，最后返回。

方法：setConnectionParametersForRequest(HttpURLConnection connection,Request<?> request)

根据request,为connection设置method,post,get,delete,put等

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

3.类BaseNetwork

主要方法

方法：addCacheHeaders(Map<String, String> headers, Cache.Entry entry)，如果存在Cache.Entry，headers.put("If-Modified-Since", DateUtils.formatDate(refTime));

方法：NetworkResponse performRequest(Request<?> request)：包装HurlStack类的方法，增加一些其他操作。

调用addCacheHeaders方法，为request增加CacheHeaders→调用hurlStack的performRequest方法获得httpResponse→获得statusLine，获得statusCode

→如果StatusCode==304，则直接返回NetworkResponse,将NetWorkResponse的notModified设为true→对于204等没有content的状态码，再确认一次，将

httpResponse的entity转换到responseContents里→状态码为200-299时，返回NetworkResponse，但notModified为false.→不是时，抛出IOException

→在catch里根据responseContent是否为null，进行对应处理，抛出异常。

方法：entityToBytes(HttpEntity entity)，将entity转换为byte[],利用到PoolingByteArrayOutputStream类，ByteArrayPool类，之前ByteArrayPool类是一个持有

不同长度的byte[]的pool，可以提供大于目标size的byte[]，防止不同size的byte[]重复创建，提供性能。PoolingByteArrayOutputStream则是利用ByteArrayPool

提供的byte[]的输出流。

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

3.类NetworkResponse

NetworkResponse(int statusCode, byte[] data, Map<String, String> headers,boolean notModified)构造方法就可以看出用途

包装后，如果server返回304，notModified就是true说明在指定时间未修改，直接从本地cache获取。

4.类ByteArrayPool，提供不同size的byte[]，提高性能

getBuf(int len),trim(),returnBuf(byte[] buf)3个主要方法。

public class ByteArrayPool 

mBuffersByLastUse = new LinkedList<byte[]>(); //用于将最近使用的byte[]添加到末尾，删除byte[]时，删除头部的，即删除最久不用的

private List<byte[]> mBuffersBySize = new ArrayList<byte[]>(64);    //按大小顺序排列的list<pre name="code" class="html">public synchronized void returnBuf(byte[] buf) {   //将buf添加到pool里

        if (buf == null || buf.length > mSizeLimit) {
            return;
        }
        mBuffersByLastUse.add(buf);      //添加到末尾，表明最近使用的
        int pos = Collections.binarySearch(mBuffersBySize, buf, BUF_COMPARATOR);      //使用二分法将buf插入到mBufferBysize里
        if (pos < 0) {
            pos = -pos - 1;
        }
        mBuffersBySize.add(pos, buf);
        mCurrentSize += buf.length;
        trim();          //添加后，确认是否超出limitSize，超出就删除旧的byte[]
    }<pre name="code" class="html">    private synchronized void trim() {
        while (mCurrentSize > mSizeLimit) {
            byte[] buf = mBuffersByLastUse.remove(0); //找到eldest的byte[]
            mBuffersBySize.remove(buf); //删除
            mCurrentSize -= buf.length;
        }
    }

    public synchronized byte[] getBuf(int len) {              //根据len获得大于该len的byte[]
        for (int i = 0; i < mBuffersBySize.size(); i++) {
            byte[] buf = mBuffersBySize.get(i);
            if (buf.length >= len) {
                mCurrentSize -= buf.length;
                mBuffersBySize.remove(i);                //移除buf
                mBuffersByLastUse.remove(buf);
                return buf;
            }
        }
        return new byte[len];
    }

5.类PoolingByteArrayOutputStream，使用ByteArrayPool的ByteArrayOutputStream，提供性能

   private void expand(int i) {    //扩展读取时用的buf
        /* Can the buffer handle @i more bytes, if not expand it */
        if (count + i <= buf.length) {
            return;
        }
        byte[] newbuf = mPool.getBuf((count + i) * 2);     //从mPool里获得byte[],size至少是原来的2倍
        System.arraycopy(buf, 0, newbuf, 0, count);
        mPool.returnBuf(buf);                         //将不用的buf return到pool里保存
        buf = newbuf;      //buf指向newbuf
    }</span><pre name="code" class="html">    public synchronized void write(byte[] buffer, int offset, int len) {  
        expand(len);         //写时调用expand方法，检查是否需要扩展，
        super.write(buffer, offset, len);
    }

    @Override
    public void close() throws IOException { //关闭，或回收时都将buf 还回pool
        mPool.returnBuf(buf);
        buf = null;
        super.close();
    }
    @Override
    public void finalize() {
        mPool.returnBuf(buf);
    }