通过Volley我们能学到什么?(2) — 刨析网络请求框架
接上一章来讲网络请求的大体过程，Volley是如何封装并使用HttpURLConnection和HttpClient的。
目录
网络请求的基本逻辑
网络请求的交互层—>BasicNetwork
封装HttpURLConnection实现网络连接
RequestQueue.java
从 通过Volley我们能学到什么?(1) — 工作原理与设计模式的NetworkDispatcher.java中的调用网络请求开始讲起。。
NetworkResponse networkResponse = mNetwork.performRequest(request);
Volley中网络请求一共分为三层，大体结构如下：
1、NetworkDispatcher获取Request对象并分发给BasicNetwork；
2、BasicNetwork得到Request对象后，配置头文件等配置信息分发给HttpStack;
3、HttpStack得到Request对象和配置信息后进行真正的网络请求；
4、HttpStack将网络请求的结果返回给BasicNetwork；
5、BasicNetwork得到返回结果，如果成功则返回给NetworkDispatcher，否则处理其他异常情况；
第一层NetworkDispatcher已讲完，这篇主要讲第二层(BasicNetwork)和第三层(HttpStack)。
网络请求的交互层
—>BasicNetwork
BasicNetwork.java
这一行代码直接调用的是BasicNetwork.java中的performRequest()方法
public NetworkResponse performRequest(Request request) throws VolleyError {
long requestStart = SystemClock.elapsedRealtime();
while (true) {
HttpResponse httpResponse = null;
byte[] responseContents = null;
Map responseHeaders = Collections.emptyMap();
try {
// Gather headers.
Map headers = new HashMap();
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) {
Entry entry = request.getCacheEntry();
if (entry == null) {
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,
responseHeaders, true,
SystemClock.elapsedRealtime() - requestStart);
}
// A HTTP 304 response does not have all header fields. We
// have to use the header fields from the cache entry plus
// the new ones from the response.
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
entry.responseHeaders.putAll(responseHeaders);
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,
entry.responseHeaders, true,
SystemClock.elapsedRealtime() - requestStart);
}
// 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,
SystemClock.elapsedRealtime() - requestStart);
} 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, SystemClock.elapsedRealtime() - requestStart);
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);
}
}
}
}
1、首先创建循环机制，使请求失败可以再次请求(3行)；
2、添加头部信息(9 - 10行)；
3、调用HttpStack对象进行网络请求，进入网络请求的第三层(11行)；
4、获取请求结果的状态(12 - 13行)；
5、更新头部信息(14行)；
6、如果获取的状态行是304则说明之前已获取过数据且服务器未做修改，直接返回上次请求的数据(16 - 32行)；
7、将数据内容写入到responseContents里(35 - 41行)；
8、请求完成，如果访问总时长超过3秒将访问的详细信息打印出来(44 - 45行)；
9、如果状态码返回是异常，报IO异常，跳转到下面的catch中(47 - 49)；
10、如果是连接异常则重新连接(53、55行)；
11、如果超时，则跳出循环向上抛异常，超时时间最大值可设置(56行)；
12、处理IO异常，如果是因为访问无权限或禁止访问这种认证问题，可以再给一次机会，否则直接抛异常(59 - 80行)；
多次网络请求机制
BasicNetwork.java
接下来我们来看一下Volley多次访问逻辑，入口为attemptRetryOnException()方法。
private static void attemptRetryOnException(String logPrefix, Request request,
VolleyError exception) throws VolleyError {
RetryPolicy retryPolicy = request.getRetryPolicy();
int oldTimeout = request.getTimeoutMs();
try {
retryPolicy.retry(exception);
} catch (VolleyError e) {
request.addMarker(
String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
throw e;
}
request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
}
1、获取Request对象里面的RetryPolicy对象，并获取超时时间(3 - 4行)；
2、调用RetryPolicy对象的retry()方法来检测是否需要重新访问(7行)；
向下看retry()的源码
DefaultRetryPolicy.java
public void retry(VolleyError error) throws VolleyError {
mCurrentRetryCount++;
mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);
if (!hasAttemptRemaining()) {
throw error;
}
}
1、重新访问次数加一(2行)；
2、累加超时时间(3行)；
3、判断重新访问次数是否大于最大访问次数(默认是1，可自定义)，大于最大值报异常跳出循环(4行)；
封装HttpURLConnection实现网络连接(HttpClient暂不整理)
如果是Android2.3即以上版本调用上面HttpStack对象的performRequest()方法的会映射到HurlStack类里面的performRequest()方法来实现网络连接。
HurlStack.java
public HttpResponse performRequest(Request request, Map additionalHeaders)
throws IOException, AuthFailureError {
String url = request.getUrl();
HashMap map = new HashMap();
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 = 0;
try {
responseCode = connection.getResponseCode();
} catch (IOException e) {
connection.getErrorStream();
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> header : connection.getHeaderFields().entrySet()) {
if (header.getKey() != null) {
Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
response.addHeader(h);
}
}
return response;
1、得到URL并获取头部信息(3 - 6行)；
2、mUrlRewriter是干什么的？mUrlRewriter默认为null，但如果赋值的话，所有使用到的网络请求URL统一替换成mUrlRewriter中的URL，应该是项目测试用的(7 - 13行)；
3、创建HttpURLConnection对象，并做一些连接前的配置，看一下这个方法的细节(15行)；
调用createConnection()方法创建一个HttpURLConnection对象，createConnection()方法里面只是判断了一下是不是通过https访问。如果是https则在
HttpsURLConnection这个类里面的两个静态对象初始化，
如果是http的话不做处理。因为如果是http的话后面的执行直接用connection这个引用就可以，如果是https的话由于已经在
HttpsURLConnection这个类中把必要的静态数据初始化了所以可以直接将connection强行转换(170行、179 - 181行)；
4、设置头部(16 - 18行)；
5、设置连接参数，支持8种请求方式(19行)；
6、获取连接最终状态，如果是-1说明不能获取到，向上抛异常(22 - 34行)；
7、配置BasicHttpResponse对象以便在最后返回它(35 - 37行)；
8、将body写入到BasicHttpResponse对象中(38行)；
9、将头部信息写入到BasicHttpResponse对象中(39 - 44行)；
这样整体的网络结构就差不多了。如果继续深入可以研究上传功能的源码和HttpUrlConnect的源码。