Android 使用OkHttp扩张Volley

我们先来回忆一下Volley的用法，使用Volley前，我们一般会先构造出一个RequestQueue，然后不断往该对象中添加请求Request，之后Volley便会进行调度，至于走缓存还是走网络这就看就没有请求过了。而构造RequestQueue的方法如下。

 Volley.newRequestQueue(mContext);

而该方法，内部实际上是调用了两个参数的重载方法

 public static RequestQueue newRequestQueue(Context context) {        return newRequestQueue(context, null);    }

我们看下两个参数的重载方法的实现。

    private static final String DEFAULT_CACHE_DIR = "volley";    public static RequestQueue newRequestQueue(Context context, HttpStack stack) {        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);        String userAgent = "volley/0";        try {            String packageName = context.getPackageName();            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);            userAgent = packageName + "/" + info.versionCode;        } catch (NameNotFoundException e) {        }        if (stack == null) {            if (Build.VERSION.SDK_INT >= 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));            }        }        Network network = new BasicNetwork(stack);        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);        queue.start();        return queue;    }

在该方法中，进行了以下几步的操作

• 创建缓存目录，即第一行代码实现的内容。
• 获得了userAgent，默认情况下是volley/0，如果能够获取到包名，则会被重写为包名/版本号
• 然后根据第二个入参HttpStack，判断是否为空，其实我们默认的构造RequestQueue中就是传了一个null，如果不为null，则使用参数，如果为null，则根据android系统的版本进行判断，如果系统版本大于等于9，则使用HurlStack，如果系统版本小于9，则使用HttpClientStack
• 之后构造Network和Cache对象，将它们传入RequestQueue的构造函数中构造RequestQueue对象，调用该对象的start方法开始死循环，在该循环中如果消息队列中有新的请求则会进行处理。

在这个过程中我们需要关心的是HurlStack和HttpClientStack到底是什么。其实这两个对象都是实现了HttpStack接口的。该接口的定义如下。

public interface HttpStack {    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)        throws IOException, AuthFailureError;}

该方法中的逻辑需要实现根据参数去完成一个请求，并返回请求结果。我们需要根据这两个实现类，去仿一个OkHttp的实现类，首先我们看一下HurlStack的实现。也就是通过HttpUrlConnection实现的

 @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);        if (hasResponseBody(request.getMethod(), responseStatus.getStatusCode())) {            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;    }

• 首先拿到url，新建了一个Map对象，往该map对象中放入了请求头的内容，请求头来自两个地方，一个是入参Request中，通过request.getHeaders()获得，一个是入参additionalHeaders中，直接add进去即可

• 然后会判断一个叫mUrlRewriter的变量是否为空，如果不为空，则调用它的rewriteUrl方法返回新的url，其实它是一个接口，其定义如下，默认情况下这个变量是空，所以这一过程不会被调用。

public interface UrlRewriter {        /**         * Returns a URL to use instead of the provided one, or null to indicate         * this URL should not be used at all.         */        public String rewriteUrl(String originalUrl);    }

• 根据url创建URL对象
• 通过openConnection方法获得了一个HttpURLConnection对象

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

在该方法中的操作，主要是打开一个连接，设置超时时间，SSLSocketFactory，是否使用缓存等内容。

• 然后通过一个for循环往获得的HttpsURLConnection对象中添加请求头，也就是刚才的map

• 调用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;            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.");        }    } 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();        }    }

该方法会会根据请求的方法调用setRequestMethod设置对应的字符串，并且如果是POST，PUT，PATCH方法，则会调用addBodyIfExists方法设置请求体

• 之后是新建一个ProtocolVersion对象，传的是HTTP 1.1
• 获得响应码，如果为-1则扔出异常
• 构造响应状态行StatusLine
• 构造响应体，会根据hasResponseBody函数判断是否有响应体内容，如果有则进行设置。

private static boolean hasResponseBody(int requestMethod, int responseCode) {    return requestMethod != Request.Method.HEAD        && !(HttpStatus.SC_CONTINUE <= responseCode && responseCode < HttpStatus.SC_OK)        && responseCode != HttpStatus.SC_NO_CONTENT        && responseCode != HttpStatus.SC_NOT_MODIFIED;}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对象中去，并返回这个对象

整个过程其实也是相当简单的，接下来看HttpClientStack的实现，该实现和HurlStack十分相似。

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

• 首先调用createHttpRequest方法设置请求的内容

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

这一步，和HurlStack中的setConnectionParametersForRequest的作用是类似的

• 根据上一步的返回结果HttpUriRequest 对象，调用addHeaders对该对象设置请求头，请求头的来源和HurlStack是一样的

private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {    for (String key : headers.keySet()) {        httpRequest.setHeader(key, headers.get(key));    }}

• 设置超时时间
• 然后调用HttpClient对象的execute方法，获得HttpResponse对象

可以从上面两个类中看到很多类似的地方

• 设置请求头
• 设置请求方法和请求体
• 设置超时时间等参数
• 设置响应头和响应体

根据这些步骤，我们写一个使用OkHttp实现的HttpStack的实现类。首先创建类OkHttpStack，实现HttpStack接口

public class OkHttpStack implements HttpStack {    @Override    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError {        return null;    }}

提供一个构造函数，传入OkHttpClient 对象

private final OkHttpClient mOkHttpClient;public OkHttpStack(OkHttpClient okHttpClient) {    if (okHttpClient == null) {        throw new IllegalArgumentException("OkHttpClient can't be null");    }    mOkHttpClient = okHttpClient;}

然后实现performRequest方法,首先我们设置一下超时时间

OkHttpClient client = mOkHttpClient.clone();int timeoutMs = request.getTimeoutMs();client.setConnectTimeout(timeoutMs, TimeUnit.MILLISECONDS);client.setReadTimeout(timeoutMs, TimeUnit.MILLISECONDS);client.setWriteTimeout(timeoutMs, TimeUnit.MILLISECONDS);

为了不对外部的OkHttpClient 造成影响，我们这里调用了clone方法克隆了一个。当然也可以直接使用原对象，即

OkHttpClient client = mOkHttpClient;int timeoutMs = request.getTimeoutMs();client.setConnectTimeout(timeoutMs, TimeUnit.MILLISECONDS);client.setReadTimeout(timeoutMs, TimeUnit.MILLISECONDS);client.setWriteTimeout(timeoutMs, TimeUnit.MILLISECONDS);

接下来设置请求头，请求头的来源有两个，上面已经解析过了。

com.squareup.okhttp.Request.Builder builder=new com.squareup.okhttp.Request.Builder();builder.url(request.getUrl());Map<String,String> headers=request.getHeaders();for(String name:headers.keySet()){    builder.addHeader(name,headers.get(name));}for(String name:additionalHeaders.keySet()){    builder.addHeader(name,additionalHeaders.get(name));}

设置请求头完毕后自然就是请求方法和请求体了，为了保持命名的约定，还是使用setConnectionParametersForRequest函数名，其实现如下

static void setConnectionParametersForRequest(com.squareup.okhttp.Request.Builder builder, Request<?> request) throws IOException, AuthFailureError {    switch (request.getMethod()) {        case Request.Method.DEPRECATED_GET_OR_POST:            byte[] postBody = request.getPostBody();            if (postBody != null) {                builder.post(RequestBody.create(MediaType.parse(request.getPostBodyContentType()),postBody));            }            break;        case Request.Method.GET:            builder.get();            break;        case Request.Method.DELETE:            builder.delete();            break;        case Request.Method.POST:            builder.post(createRequestBody(request));            break;        case Request.Method.PUT:            builder.put(createRequestBody(request));            break;        case Request.Method.HEAD:            builder.head();            break;        case Request.Method.OPTIONS:            builder.method("OPTIONS",null);            break;        case Request.Method.TRACE:            builder.method("TRACE",null);            break;        case Request.Method.PATCH:            builder.patch(createRequestBody(request));            break;        default:            throw new IllegalStateException("Unknown method type.");    }}

内部还调用了createRequestBody方法设置请求体，其实现如下

private static RequestBody createRequestBody(Request r) throws AuthFailureError{    final byte[] body = r.getBody();    if (body == null) return null;    return RequestBody.create(MediaType.parse(r.getBodyContentType()), body);}

设置完毕后，自然就是开始请求了

com.squareup.okhttp.Request okRequest=builder.build();Call call=client.newCall(okRequest);Response okresponse=call.execute();

请求完毕，对响应头和响应体进行设置。
首先获得请求的协议

private static ProtocolVersion parseProtocol(final Protocol p){    switch (p)    {        case HTTP_1_0:            return new ProtocolVersion("HTTP", 1, 0);        case HTTP_1_1:            return new ProtocolVersion("HTTP", 1, 1);        case SPDY_3:            return new ProtocolVersion("SPDY", 3, 1);        case HTTP_2:            return new ProtocolVersion("HTTP", 2, 0);    }    throw new IllegalAccessError("Unkwown protocol");}

构造响应状态行

BasicStatusLine responseStatus = new BasicStatusLine(            parseProtocol(okresponse.protocol()),            okresponse.code(),            okresponse.message()    );

设置响应体

BasicHttpResponse response=new BasicHttpResponse(responseStatus);response.setEntity(entityFromOkHttpResponse(okresponse));

entityFromOkHttpResponse函数的实现如下，包括对响应内容，响应内容长度，响应内容编码，响应类型进行设置

private static HttpEntity entityFromOkHttpResponse(Response r) throws IOException{    BasicHttpEntity entity = new BasicHttpEntity();    ResponseBody body = r.body();    entity.setContent(body.byteStream());    entity.setContentLength(body.contentLength());    entity.setContentEncoding(r.header("Content-Encoding"));    if (body.contentType() != null)    {        entity.setContentType(body.contentType().type());    }    return entity;}

设置响应头

int size=responseHeaders.size();String name=null;String value=null;for(int i=0;i<size;i++){    name=responseHeaders.name(i);    if (name!=null){        response.addHeader(new BasicHeader(name,value));    }}

最后返回HttpResponse对象

 return response;

贴一下全部的代码

public class OkHttpStack implements HttpStack {    private final OkHttpClient mOkHttpClient;    public OkHttpStack(OkHttpClient okHttpClient) {        if (okHttpClient == null) {            throw new IllegalArgumentException("OkHttpClient can't be null");        }        mOkHttpClient = okHttpClient;    }    @Override    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError {        OkHttpClient client = mOkHttpClient;        int timeoutMs = request.getTimeoutMs();        client.setConnectTimeout(timeoutMs, TimeUnit.MILLISECONDS);        client.setReadTimeout(timeoutMs, TimeUnit.MILLISECONDS);        client.setWriteTimeout(timeoutMs, TimeUnit.MILLISECONDS);        com.squareup.okhttp.Request.Builder builder = new com.squareup.okhttp.Request.Builder();        builder.url(request.getUrl());        Map<String, String> headers = request.getHeaders();        for (String name : headers.keySet()) {            builder.addHeader(name, headers.get(name));        }        for (String name : additionalHeaders.keySet()) {            builder.addHeader(name, additionalHeaders.get(name));        }        setConnectionParametersForRequest(builder, request);        com.squareup.okhttp.Request okRequest = builder.build();        Call call = client.newCall(okRequest);        Response okresponse = call.execute();        BasicStatusLine responseStatus = new BasicStatusLine(                parseProtocol(okresponse.protocol()),                okresponse.code(),                okresponse.message()        );        BasicHttpResponse response = new BasicHttpResponse(responseStatus);        response.setEntity(entityFromOkHttpResponse(okresponse));        Headers responseHeaders = okresponse.headers();        int size = responseHeaders.size();        String name = null;        String value = null;        for (int i = 0; i < size; i++) {            name = responseHeaders.name(i);            if (name != null) {                response.addHeader(new BasicHeader(name, value));            }        }        return response;    }    private static HttpEntity entityFromOkHttpResponse(Response r) throws IOException {        BasicHttpEntity entity = new BasicHttpEntity();        ResponseBody body = r.body();        entity.setContent(body.byteStream());        entity.setContentLength(body.contentLength());        entity.setContentEncoding(r.header("Content-Encoding"));        if (body.contentType() != null) {            entity.setContentType(body.contentType().type());        }        return entity;    }    static void setConnectionParametersForRequest(com.squareup.okhttp.Request.Builder builder, Request<?> request) throws IOException, AuthFailureError {        switch (request.getMethod()) {            case Request.Method.DEPRECATED_GET_OR_POST:                byte[] postBody = request.getPostBody();                if (postBody != null) {                    builder.post(RequestBody.create(MediaType.parse(request.getPostBodyContentType()), postBody));                }                break;            case Request.Method.GET:                builder.get();                break;            case Request.Method.DELETE:                builder.delete();                break;            case Request.Method.POST:                builder.post(createRequestBody(request));                break;            case Request.Method.PUT:                builder.put(createRequestBody(request));                break;            case Request.Method.HEAD:                builder.head();                break;            case Request.Method.OPTIONS:                builder.method("OPTIONS", null);                break;            case Request.Method.TRACE:                builder.method("TRACE", null);                break;            case Request.Method.PATCH:                builder.patch(createRequestBody(request));                break;            default:                throw new IllegalStateException("Unknown method type.");        }    }    private static ProtocolVersion parseProtocol(final Protocol p) {        switch (p) {            case HTTP_1_0:                return new ProtocolVersion("HTTP", 1, 0);            case HTTP_1_1:                return new ProtocolVersion("HTTP", 1, 1);            case SPDY_3:                return new ProtocolVersion("SPDY", 3, 1);            case HTTP_2:                return new ProtocolVersion("HTTP", 2, 0);        }        throw new IllegalAccessError("Unkwown protocol");    }    private static RequestBody createRequestBody(Request r) throws AuthFailureError {        final byte[] body = r.getBody();        if (body == null) return null;        return RequestBody.create(MediaType.parse(r.getBodyContentType()), body);    }}

至于用法，也很简单，在创建RequestQueue对象的时候，第二个参数传入我们的OkHttpStack对象即可。

  Volley.newRequestQueue(this,new OkHttpStack(new OkHttpClient()));

此外，网上还有一种更加简洁的实现，但是得添加okhttp-urlconnection依赖

compile 'com.squareup.okhttp:okhttp:2.5.0'compile 'com.squareup.okhttp:okhttp-urlconnection:2.5.0'

该实现不是通过实现HttpStack接口实现的，而是继承HurlStack类实现的

public class SimpleOkHttpStack extends HurlStack {    private final OkUrlFactory okUrlFactory;    public SimpleOkHttpStack() {        this(new OkHttpClient());    }    public SimpleOkHttpStack(OkHttpClient okHttpClient) {        if (okHttpClient == null) {            throw new NullPointerException("Client must not be null.");        }        this.okUrlFactory = new OkUrlFactory(okHttpClient);    }    @Override    protected HttpURLConnection createConnection(URL url) throws IOException {        return okUrlFactory.open(url);    }}

甚至你可以选择继承HttpClientStack ，传入OkHttp内部的OkApacheClient实现类，当然也需要添加依赖

compile 'com.squareup.okhttp:okhttp-apache:2.5.0'

public class SimpleHttpClientStack extends HttpClientStack {    public SimpleHttpClientStack(OkHttpClient client) {        super(new OkApacheClient(client));    }}

基本上所有的扩展方法都说了一遍，第一种是完全自己实现，第二种是选择继承现有的类去实现，这个思路和Androd开发中自定义View的思路基本一致，至于选择哪一种，完全看你自己需要。