Volley框架的基本解读(四)

废话不多说，放上Volley框架的基本解读(三)的链接，我们继续往下看，先来看看网络执行类HttpStack的源码：

/**
 * An HTTP stack abstraction.
 */
public interface HttpStack {
    /**
     * Performs an HTTP request with the given parameters.
     *
     * <p>A GET request is sent if request.getPostBody() == null. A POST request is sent otherwise,
     * and the Content-Type header is set to request.getPostBodyContentType().</p>
     *
     * @param request the request to perform
     * @param additionalHeaders additional headers to be sent together with
     *         {@link Request#getHeaders()}
     * @return the HTTP response
     * 
     * 真正的网络请求
     */
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
        throws IOException, AuthFailureError;

}

这是一个接口，里面有一个与Network接口同名，但又不一样的方法。

具体实现是由Volley.newRequestQueue中根据api版本不同，创建的HurlStack或HttpClientStack，前面已经说过两者之间的差别，我们选版本高的来讲，这里值得一提的是，之所以在api9之后不用HttpClient，是因为它有所缺陷，好了，进入正题：

public HurlStack() {
        this(null);
    }

继续看：

public HurlStack(UrlRewriter urlRewriter) {
        this(urlRewriter, null);
    }

再看：

public HurlStack(UrlRewriter urlRewriter, SSLSocketFactory sslSocketFactory) {
        mUrlRewriter = urlRewriter;
        mSslSocketFactory = sslSocketFactory;
    }

UrlRewriter是HurlStack中的一个内部接口，用于URL的重置，我们给的是null，所以不用管它，SSLSocketFactory是https协议用到的类，我们给的也是null,所以也不需要管它，直入主题看performRequest方法：

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

前面都很简单，我们直接看第16行的openConnection方法：

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
        // 如果是https协议
        if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
            ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
        }

        return connection;
    }

再看createConnection方法：

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

很简单吧，仅仅只是封装了(HttpURLConnection) url.openConnection()这一句代码而已，那么上面也就简单了，只是对网络请求进行了一些简单的设置，判断是否是https协议，进行设置。

这里提一点request.getTimeoutMs()获取到的时间其实是DefaultRetryPolicy中mCurrentTimeoutMs，当请求重试时，连接超时的时间会被延长。

随后就是添加请求头，setConnectionParametersForRequest方法用于确定请求方式：

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

包含GET，DELETE，POST，PUT等等，第一种请无视它，大概的意思是这是过时的，需要处理的向后兼容性，如果该请求的正文无效，则该假设是该请求是GET，否则是POST，老实说我也不知道它想表达什么意思，如果有大神知道还望指教！

之后就是为了统一返回方式，将HttpURLConnection中的属性给予了封装，先是http协议版本，然后封装成状态行，再然后放入BasicHttpResponse中，设置实体，entityFromConnection方法，猜也猜的到是做什么用的：

/**
     * Initializes an {@link HttpEntity} from the given {@link HttpURLConnection}.
     * @param connection
     * @return an HttpEntity populated with data from <code>connection</code>.
     * 
     * 将HttpURLConnection换成HttpEntity
     */
    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;
    }

很简单，我就不废话了。

最后添加响应头，一个HttpResponse就封装完成了。

到此Volley网络请求这一条线，我们已经全部走完了，希望各位读者能有所收获！