volley源代码解析(六)--HurlStack与HttpClientStack之争

Volley中网络载入有两种方式，各自是HurlStack与HttpClientStack。我们来看Volley.java中的一段代码

if (stack == null) {//假设没有限定stack
            if (Build.VERSION.SDK_INT >= 9) {//adk版本号在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，则依据当前adk版本号自己主动选择。在Android 2.2版本号之前，HttpClient拥有较少的bug。因此使用它是最好的选择。

而在Android 2.3版本号及以后。HttpURLConnection则是最佳的选择。

它的API简单。体积较小，因而很适用于Android项目。压缩和缓存机制能够有效地降低网络訪问的流量，在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection，由于在以后的工作其中我们也会将很多其它的时间放在优化HttpURLConnection上面。

为此，我们须要分别来看这两个类。在看这两个之前，我们先来看它们一个简单的父类HttpStack

/**
 * An HTTP stack abstraction.
 * 抽象的http栈
 */
public interface HttpStack {
    /**
     * Performs an HTTP request with the given parameters.
     * 依据參数。运行http请求
     * <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;

}

该父类主要规定了，子类必须有一个依据request请求数据，而且返回HttpResponse类的方法

OK，接下来我们先看HurlStack，这个类使用的是HttpURLConnection作为连接方式，在adk较高版本号推荐使用(事实上眼下市场上2.3的系统已经非常少见了)

我们直接看这个类的核心方法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);//http协议
        int responseCode = connection.getResponseCode();//获取响应状态
        if (responseCode == -1) {//-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;
    }

整个方法分成几个步骤，首先是将请求參数。存储到map其中

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

然后是开启url连接

URL parsedUrl = new URL(url);
        HttpURLConnection connection = openConnection(parsedUrl, request);//开启连接

来看openConnection()方法

/**
     * Opens an {@link HttpURLConnection} with parameters.
     * 开启网络连接
     * @param url
     * @return an open connection
     * @throws IOException
     */
    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) {//https
            ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
        }

        return connection;
    }

   /**
     * Create an {@link HttpURLConnection} for the specified {@code url}.
     */
    protected HttpURLConnection createConnection(URL url) throws IOException {
        return (HttpURLConnection) url.openConnection();
    }

这种方法主要就是调用url.openConnevtion()从而返回一个HttpURLConnection对象。当中的一些超时设置，是由request本身提供的

另外还依据url是否带有https。为HttpURLConnection设置setSSLSocketFactory（mSslSocketFactory对象是在构造方法中传入的）

得到HttpURLConnection，就设置请求參数

for (String headerName : map.keySet()) {//加入请求參数
            connection.addRequestProperty(headerName, map.get(headerName));
        }

然后是确定请求方式(GET,POST还是别的)

setConnectionParametersForRequest(connection, request);//设置请求方式

setConnectionParametersForRequest方法：

@SuppressWarnings("deprecation")
    /**
     * 设置请求方式
     * @param connection
     * @param request
     * @throws IOException
     * @throws AuthFailureError
     */
    /* package */
    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;
            case Method.HEAD:
                connection.setRequestMethod("HEAD");
                break;
            case Method.OPTIONS:
                connection.setRequestMethod("OPTIONS");
                break;
            case Method.TRACE:
                connection.setRequestMethod("TRACE");
                break;
            case Method.PATCH:
                connection.setRequestMethod("PATCH");
                addBodyIfExists(connection, request);
                break;
            default:
                throw new IllegalStateException("Unknown method type.");
        }
    }

最后获取响应。将响应头信息包装成StatusLine对象，再包装成BasicHttpResponse对象

StatusLine responseStatus = new BasicStatusLine(protocolVersion,
                connection.getResponseCode(), connection.getResponseMessage());//响应状态类
        BasicHttpResponse response = new BasicHttpResponse(responseStatus);

然后为BasicHttpResponse增加响应内容

 response.setEntity(entityFromConnection(connection));//解析响应实体

entityFromConnection(HttpURLConnection connection)方法：

/**
     * Initializes an {@link HttpEntity} from the given {@link HttpURLConnection}.
     * <br>解析出响应实体
     * @param connection
     * @return an HttpEntity populated with data from <code>connection</code>.
     */
    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;
    }

最后，增加响应头部内容

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

OK。这样就返回了一个具有完整信息的HttpResponse对象。整个过程比較简单，是常规的网络请求内容。

接下来我们看HttpClientStack的实现

相同。直接来看performRequest()方法

@Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
        HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
        addHeaders(httpRequest, additionalHeaders);//加入缓存头
        addHeaders(httpRequest, request.getHeaders());//加入请求头
        onPrepareRequest(httpRequest);//请求预处理
        HttpParams httpParams = httpRequest.getParams();
        int timeoutMs = request.getTimeoutMs();
        // TODO: Reevaluate this connection timeout based on more wide-scale
        // data collection and possibly different for wifi vs. 3G.
        HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
        HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
        return mClient.execute(httpRequest);
    }

请求步骤，首先是依据请求方式。构造HttpUriRequest对象，而且设置请求參数

HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);

createHttpRequest()方法：

/**
     * Creates the appropriate subclass of HttpUriRequest for passed in request.
     * 依据请求方式返回相应HttpUriRequest的子类
     */
    @SuppressWarnings("deprecation")
    /* protected */
    static HttpUriRequest createHttpRequest(Request<?> request,
            Map<String, String> additionalHeaders) throws 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) {
                    HttpPost postRequest = new HttpPost(request.getUrl());
                    postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
                    HttpEntity entity;
                    entity = new ByteArrayEntity(postBody);
                    postRequest.setEntity(entity);
                    return postRequest;
                } else {
                    return new HttpGet(request.getUrl());
                }
            }
            case Method.GET:
                return new HttpGet(request.getUrl());
            case Method.DELETE:
                return new HttpDelete(request.getUrl());
            case Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(postRequest, request);//设置请求參数
                return postRequest;
            }
            case Method.PUT: {
                HttpPut putRequest = new HttpPut(request.getUrl());
                putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(putRequest, request);
                return putRequest;
            }
            case Method.HEAD:
                return new HttpHead(request.getUrl());
            case Method.OPTIONS:
                return new HttpOptions(request.getUrl());
            case Method.TRACE:
                return new HttpTrace(request.getUrl());
            case Method.PATCH: {
                HttpPatch patchRequest = new HttpPatch(request.getUrl());
                patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(patchRequest, request);
                return patchRequest;
            }
            default:
                throw new IllegalStateException("Unknown request method.");
        }
    }

从createHttpRequest()方法能够看出。在HttpClient中，仅仅要依据请求方式，new一个HttpGet/HttpPost/....对象就能够了(而urlstack这一步是真的connnection而言的)

接着是为HttpUriRequest对象设置请求头部

 addHeaders(httpRequest, additionalHeaders);//加入缓存头
        addHeaders(httpRequest, request.getHeaders());//加入请求头

addHeaders方法：

/**
     * 加入响应头
     * @param httpRequest
     * @param headers
     */
    private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {
        for (String key : headers.keySet()) {
            httpRequest.setHeader(key, headers.get(key));
        }
    }

最后，将HttpUriRequest对象交给httpClient运行

 return mClient.execute(httpRequest);

OK，HttpClientStack比我们想象的还要简单。起码比HurlStack简单，这是当然的。由于使用httpClient方式，其本质就是对urlConnection的封装，然而这个封装并非非常完美。所以造成了版本号之间的差异。

到此为止，给大家介绍了HurlStack与HttpClientStack这两个类，同一时候也说明了真正的网络请求在哪里运行。

下一篇文章，将会来了解Response<T>的使用，Response<T>是Volley整个过程中。辗转获得的终于目的，作为响应实体。我们来看一下Response<T>是怎么设计的。

时间： 2024-10-18 14:56:17

volley源代码解析(六)--HurlStack与HttpClientStack之争的相关文章

volley源码解析(六)--HurlStack与HttpClientStack之争

Volley中网络加载有两种方式,分别是HurlStack与HttpClientStack,我们来看Volley.java中的一段代码 if (stack == null) {//如果没有限定stack if (Build.VERSION.SDK_INT >= 9) {//adk版本在9或者以上 stack = new HurlStack(); } else { // Prior to Gingerbread, HttpUrlConnection was unreliable. // See:

Spring源代码解析

Spring源代码解析(一):IOC容器:http://www.iteye.com/topic/86339 Spring源代码解析(二):IoC容器在Web容器中的启动:http://www.iteye.com/topic/86594 Spring源代码解析(三):Spring JDBC:http://www.iteye.com/topic/87034 Spring源代码解析(四):Spring MVC:http://www.iteye.com/topic/87692 Spring源代码解析(五

Spring源代码解析(收藏)

Spring源代码解析(收藏)Spring源代码解析(一):IOC容器:http://www.iteye.com/topic/86339 Spring源代码解析(二):IoC容器在Web容器中的启动:http://www.iteye.com/topic/86594 Spring源代码解析(三):Spring JDBC:http://www.iteye.com/topic/87034 Spring源代码解析(四):Spring MVC:http://www.iteye.com/topic/8769

Android源代码解析之（六）--&amp;gt;Log日志

转载请标明出处:一片枫叶的专栏 首先说点题外话,对于想学android framework源代码的同学,事实上能够在github中fork一份,详细地址:platform_frameworks_base 这里面基本都是android framework层的源代码了.并且近期发现了一个比較不错的github插件:OctoTree,它 是一个浏览器插件,它能够让你在Github 看代码时,左边栏会出现一个树状结构.就像我们在IDE 一样.当我们看一个项目的结构,或者想看详细的某个文件,这样就会非常方

Android 网络通信框架Volley的解析

在2013年Google I/O大会上,Android开发团队公布了一个新的网络通信框架:Volley.它适合处理通信频繁的网络操作,但对于每一次通信的数据量则有较为苛刻的限制.本文将介绍该通信框架的用法(包括使用现成和自定义的Request),并从源码的角度探究其工作机制. 目前,Android系统中用于实现HTTP通信的方式主要有HttpURLConnection和HttpClient两个类[1],而封装了它们的框架主要有AsyncHttpClient和Universal-Image-Loa

[转]Android Volley完全解析(四)，带你从源码的角度理解Volley

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/17656437 经过前三篇文章的学习,Volley的用法我们已经掌握的差不多了,但是对于Volley的工作原理,恐怕有很多朋友还不是很清楚.因此,本篇文章中我们就来一起阅读一下Volley的源码,将它的工作流程整体地梳理一遍.同时,这也是Volley系列的最后一篇文章了. 其实,Volley的官方文档中本身就附有了一张Volley的工作流程图,如下图所示. 多数朋友突然看到一张这样

Android Volley完全解析(四)，带你从源码的角度理解Volley

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/17656437 经过前三篇文章的学习,Volley的用法我们已经掌握的差不多了,但是对于Volley的工作原理,恐怕有很多朋友还不是很清楚.因此,本篇文章中我们就来一起阅读一下Volley的源码,将它的工作流程整体地梳理一遍.同时,这也是Volley系列的最后一篇文章了. 其实,Volley的官方文档中本身就附有了一张Volley的工作流程图,如下图所示. 多数朋友突然看到一张这样

Android View体系（八）从源代码解析View的layout和draw流程

相关文章 Android View体系(一)视图坐标系 Android View体系(二)实现View滑动的六种方法 Android View体系(三)属性动画 Android View体系(四)从源代码解析Scroller Android View体系(五)从源代码解析View的事件分发机制 Android View体系(六)从源代码解析Activity的构成 Android View体系(七)从源代码解析View的measure流程 前言 上一篇文章我们讲了View的measure的流程.接

使用NoSQL实现高并发CRM系统实践(源代码+解析)

又想速度快,又要大数据,又要保证数据不出错,还要拥抱变化,改需求的时候不那么痛苦,特别是字段的调整,按照以前的做法,想想就头疼.使用NoSQL,简直就是随心所欲,再奇葩的数据结构,处理起来也很容易.下面看我如何用NoSQL数据库实现高并发,高可靠的CRM系统. 1.前言 随着facebook.微博等WEB2.0互联网网站的兴起,传统的关系数据库在应付web2.0网站,特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心,暴露了很多难以克服的问题,而非关系型的数据库则由于其本