android网络框架volley学习之HttpStack接口

    这篇博文将介绍Volley框架的实际网络访问类HurlStack和HttpClientStack.这两个类均实现了HttpStack接口，只是采用了不同的网络访问类。HurlStack类是利用通过URL打开httpURLconnection网络通信连接，实现了网络访问。而HttpClientStack则是利用android中org.apache.http系列的开发包实现网络访问，实现过程较为简单。这两个类都是是Volley进行网络访问的实际类。

    下面逐个查看这两个类的代码

HurlStack类

//利用httpURLconnection建立一个httpStack
public class HurlStack implements HttpStack {

    private static final String HEADER_CONTENT_TYPE = "Content-Type";
  
    //接口用于重新书写URL
    public interface UrlRewriter {
        public String rewriteUrl(String originalUrl);
    }

    private final UrlRewriter mUrlRewriter;

    public HurlStack() {
        this(null);
    }

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

    public HurlStack(UrlRewriter urlRewriter, SSLSocketFactory sslSocketFactory) {
        mUrlRewriter = urlRewriter;
        mSslSocketFactory = sslSocketFactory;
    }
     //实现未实现的方法
    @Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
	//获取请求体中的URL
        String url = request.getUrl();
	//建立一个map用于存放请求头信息
        HashMap<String, String> map = new HashMap<String, String>();
	//将原来请求体中的请求头添加到map中
        map.putAll(request.getHeaders());
	//添加额外的请求头
        map.putAll(additionalHeaders);
	//如果mUrlRewriter不为空则重写URL
        if (mUrlRewriter != null) {
            String rewritten = mUrlRewriter.rewriteUrl(url);
            if (rewritten == null) {
                throw new IOException("URL blocked by rewriter: " + url);
            }
            url = rewritten;
        }

	//通过String建立URL对象
        URL parsedUrl = new URL(url);

	//打开http通信链接
        HttpURLConnection connection = openConnection(parsedUrl, request);

	//为通信连接添加请求头
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }

	//设置通信链接的参数
        setConnectionParametersForRequest(connection, request);

        /* 用请求回来的响应来构造HTTPResponse对象
         *1、建立协议控制版本的对象。
         *2、利用协议版本对象构建响应行对象。
         *3、构建HTTPResponse对象。
        **/
        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);
        //为HTTPResponse添加实体
        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 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;
    }
    //建立http通信链接
    protected HttpURLConnection createConnection(URL url) throws IOException {
        return (HttpURLConnection) url.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
        if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
            ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
        }

        return connection;
    }
        //根据请求体的方法 对通信链接的参数进行设置
	static void setConnectionParametersForRequest(HttpURLConnection connection,
            Request<?> request) throws IOException, AuthFailureError {
        switch (request.getMethod()) {
            case Method.GET:
                //这里其实不需要设置get方法，因为connection默认的就是get方法
                connection.setRequestMethod("GET");
                break;
            case Method.POST:
                connection.setRequestMethod("POST");
                addBodyIfExists(connection, request);
                break;
        }
    }
     //如果是post方法则添加请求体
    private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
            throws IOException, AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            connection.setDoOutput(true);//设置允许输出
            connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(body);
            out.close();
        }
    }
}

整个网络访问和生成httpResponse对象的步骤基本可以概括为：

    1、通过URL建立网络通信连接得到httpURLconnection对象。

    2、对httpURLconnection对象进行一系列的设置，包括方法、请求头、以及访问链接超时等，如果是post请求则需要设置httpURLconnection的输出为true，接着用流的形式写入到请求体中。

    3、建立协议控制版本的对象，同时利用协议版本对象构建响应行对象最终生成HTTPResponse对象。

    4、为生成的HTTPResponse对象（通过httpURLconnection对象）添加实体和响应头。

HttpClientStack类

public class HttpClientStack implements HttpStack {
    
    //请求的客户端
    protected final HttpClient mClient;

    //内容类型的头
    private final static String HEADER_CONTENT_TYPE = "Content-Type";
	
    //构造函数 
    public HttpClientStack(HttpClient client) {
        mClient = client;
    }
    //添加头信息
    private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {
        for (String key : headers.keySet()) {
            httpRequest.setHeader(key, headers.get(key));
        }
    }
    //将map形式的请求参数转化成NameValuePair对象存储在list集合中
    private static List<NameValuePair> getPostParameterPairs(Map<String, String> postParams) {
        List<NameValuePair> result = new ArrayList<NameValuePair>(postParams.size());
        for (String key : postParams.keySet()) {
            result.add(new BasicNameValuePair(key, postParams.get(key)));
        }
        return result;
    }

    @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());//添加从request中获取的请求头
        HttpParams httpParams = httpRequest.getParams();//获取请求的参数的引用
        int timeoutMs = request.getTimeoutMs();
        //通过HttpConnectionParams的静态方法对httpParams的一些参数进行设置
        HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
        HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
        return mClient.execute(httpRequest);//执行请求同时返回HTTPResponse对象
    }

    //根据request对象的方法建立不同的请求报文
    static HttpUriRequest createHttpRequest(Request<?> request,
            Map<String, String> additionalHeaders) throws AuthFailureError {
        switch (request.getMethod()) {
            //创建get请求httpGet
            case Method.GET:
                return new HttpGet(request.getUrl());
            //创建post请求httpPost
            case Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(postRequest, request);
                return postRequest;
            }
        }
    }
    //为post请求添加实体
    private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
            Request<?> request) throws AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            HttpEntity entity = new ByteArrayEntity(body);
            httpRequest.setEntity(entity);
        }
    }
}

HttpClientStack生成httpResponse的过程如下：

    1、建立httpclient，android中实现的类有DefaultHttpClient和AndroidHttpClient。

    2、根据request的方法创建不同的请求报文（post请求需要添加实体）。

    3、为请求添加请求头同时设置一些参数信息。

    4、调用httpclient的execute方法执行请求，生成httpResponse对象并返回。

    以上就基于httpStack接口的两个最真实的网络访问类的实现过程。前面也是多次提到在什么情况使用HurlStack类喝HttpClientStack类，这里就不说明了。

   不对之处，请大家指正，谢谢！