在上一篇的讲解中我们基本走了一遍Volley框架的基本请求过程，但是上一篇的请求是在缓存中获取数据的，这篇文章我们着重讲解从网络获取数据的过程。我们在上一篇中知道，Volley框架的两个核心线程是CacheDispatcher线程和NetworkDispatcher线程，前者是关于读取缓存队列的线程，后者是读取网络队列的线程，上篇讲了前者，今天就将后者线程吧。如果忘记了一些概念或者流程就去前面一篇恶补一下吧
直接上NetworkDispatcher的run方法里面的代码
public void run() {
Process.setThreadPriority(10);
while(true) {
Request request;
while(true) {
try {
1 request = (Request)this.mQueue.take();
break;
} catch (InterruptedException var4) {
if(this.mQuit) {
return;
}
}
}
try {
request.addMarker("network-queue-take");
if(request.isCanceled()) {
request.finish("network-discard-cancelled");
} else {
if(VERSION.SDK_INT >= 14) {
TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
}
2 NetworkResponse e = this.mNetwork.performRequest(request);
request.addMarker("network-http-complete");
if(e.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
} else {
3 Response response = request.parseNetworkResponse(e);
request.addMarker("network-parse-complete");
if(request.shouldCache() && response.cacheEntry != null) {
this.mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
request.markDelivered();
4 this.mDelivery.postResponse(request, response);
}
}
} catch (VolleyError var5) {
this.parseAndDeliverNetworkError(request, var5);
} catch (Exception var6) {
VolleyLog.e(var6, "Unhandled exception %s", new Object[]{var6.toString()});
this.mDelivery.postError(request, new VolleyError(var6));
}
}
}这段代码很长，其实主要的逻辑方式跟CacheDispatcher差不多，所以主要讲重点地方，其余一些细节的地方只能自己花时间深入看了，因为都不是特别难。看标记1的这句request = (Request)this.mQueue.take();
mQueue是个 BlockingQueue类型，这句其实就是从网络队列里面获得一个reques请求。然后对这个request进行addMark操作，判断这个request是否取消了等等，都是一些细节的处理，我们重点重点重点（重要的事情说三遍）看标记2这句，就是下面这句
NetworkResponse e = this.mNetwork.performRequest(request);
mNetwork是个Network类型，这个实例就是我们在传入RequestQueue的构造函数的network1，看下当时的两句代码当
BasicNetwork network1 = new BasicNetwork((HttpStack)stack);
RequestQueue queue1 = new RequestQueue(new DiskBasedCache(cacheDir), network1);所以现在我们要对network1的performRequest方法源码进行分析
BasicNetwork.java
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
long requestStart = SystemClock.elapsedRealtime();
while(true) {
HttpResponse httpResponse = null;
Object responseContents = null;
HashMap responseHeaders = new HashMap();
try {
HashMap e = new HashMap();
this.addCacheHeaders(e, request.getCacheEntry());
1 httpResponse = this.mHttpStack.performRequest(request, e);
StatusLine statusCode2 = httpResponse.getStatusLine();
int networkResponse1 = statusCode2.getStatusCode();
Map responseHeaders1 = convertHeaders(httpResponse.getAllHeaders());
if(networkResponse1 == 304) {
return new NetworkResponse(304, request.getCacheEntry().data, responseHeaders1, true);
}
byte[] responseContents1;
if(httpResponse.getEntity() != null) {
responseContents1 = this.entityToBytes(httpResponse.getEntity());
} else {
responseContents1 = new byte[0];
}
long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
this.logSlowRequests(requestLifetime, request, responseContents1, statusCode2);
if(networkResponse1 >= 200 && networkResponse1 <= 299) {
return new NetworkResponse(networkResponse1, responseContents1, responseHeaders1, false);
}
throw new IOException();
} catch (SocketTimeoutException var12) {
attemptRetryOnException("socket", request, new TimeoutError());
} catch (ConnectTimeoutException var13) {
attemptRetryOnException("connection", request, new TimeoutError());
} catch (MalformedURLException var14) {
throw new RuntimeException("Bad URL " + request.getUrl(), var14);
} catch (IOException var15) {
boolean statusCode = false;
NetworkResponse networkResponse = null;
if(httpResponse == null) {
throw new NoConnectionError(var15);
}
int statusCode1 = httpResponse.getStatusLine().getStatusCode();
VolleyLog.e("Unexpected response code %d for %s", new Object[]{Integer.valueOf(statusCode1), request.getUrl()});
if(responseContents == null) {
throw new NetworkError(networkResponse);
}
networkResponse = new NetworkResponse(statusCode1, (byte[])responseContents, responseHeaders, false);
if(statusCode1 != 401 && statusCode1 != 403) {
throw new ServerError(networkResponse);
}
attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));
}
}
}这段代码很长，我们还是着重看网络请求的处理过程，network其实并没有真正的去做网络请求，我们知道在java api里面有个HttpURLConnection这个类对吧，这个类会做网络请求的事情，这里也是，Volley框架里面也是用到了HttpURLConnection和HttpClient这两个类，至于用哪个类是根据sdk版本来决定的，这两个实例就是在Volley这个类的newRequestQueue这个方法里面生成的，忘了的可以回去看看。我们看标记1的这句
httpResponse = this.mHttpStack.performRequest(request, e);
e是个Hashmap类型，如果为空就说明本地没有该request的response，如果不为空就说明本地的response已经过期了需要重新去网络请求，设置一些header的信息。mHttpStack是个HurlStack类型（这里我们暂时以这个类型做说明，因为有可能是HttpClientStack类型，逻辑功能完全一样，没必要纠结）我们来看看HurlStack的performRequest方法
public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError {
String url = request.getUrl();
HashMap map = new HashMap();
map.putAll(request.getHeaders());
map.putAll(additionalHeaders);
if(this.mUrlRewriter != null) {
String parsedUrl = this.mUrlRewriter.rewriteUrl(url);
if(parsedUrl == null) {
throw new IOException("URL blocked by rewriter: " + url);
}
url = parsedUrl;
}
URL parsedUrl1 = new URL(url);
1 HttpURLConnection connection = this.openConnection(parsedUrl1, request);
Iterator responseCode = map.keySet().iterator();
while(responseCode.hasNext()) {
String protocolVersion = (String)responseCode.next();
connection.addRequestProperty(protocolVersion, (String)map.get(protocolVersion));
}
setConnectionParametersForRequest(connection, request);
ProtocolVersion protocolVersion1 = new ProtocolVersion("HTTP", 1, 1);
int responseCode1 = connection.getResponseCode();
if(responseCode1 == -1) {
throw new IOException("Could not retrieve response code from HttpUrlConnection.");
} else {
BasicStatusLine responseStatus = new BasicStatusLine(protocolVersion1, connection.getResponseCode(), connection.getResponseMessage());
BasicHttpResponse response = new BasicHttpResponse(responseStatus);
response.setEntity(entityFromConnection(connection));
Iterator var12 = connection.getHeaderFields().entrySet().iterator();
while(var12.hasNext()) {
Entry header = (Entry)var12.next();
if(header.getKey() != null) {
BasicHeader h = new BasicHeader((String)header.getKey(), (String)((List)header.getValue()).get(0));
response.addHeader(h);
}
}
return response;
}
}这段代码主要就是HttpURLConnection请求，代码标记1HttpURLConnection connection = this.openConnection(parsedUrl1, request);最终会调用到(HttpURLConnection)url.openConnection();这句，并且会设置一些连接属性，获得connection之后就会添加请求header信息，然后看这句
response.setEntity(entityFromConnection(connection));
我们再看下entityFromConnection(connection)这个方法
private static HttpEntity entityFromConnection(HttpURLConnection connection) {
BasicHttpEntity entity = new BasicHttpEntity();
InputStream inputStream;
try {
inputStream = connection.getInputStream();
} catch (IOException var4) {
inputStream = connection.getErrorStream();
}
entity.setContent(inputStream); entity.setContentLength((long)connection.getContentLength()); entity.setContentEncoding(connection.getContentEncoding());
entity.setContentType(connection.getContentType());
return entity;
}很明显这个方法里面就是保存了我们所需要的响应数据，看到这句entity.setContent(inputStream);没，说明我们存的是connection的输入流，这里并没有真正的已经获取到数据了，这其实有好处的，以后如果我们要获取数据应该是通过这个输入流来获取的，还存了其他一些header信息，然后将entity封装到response里面返回，这里我们通过网络请求得到的数据成功返回了，我们回头再看BasicNetwork的performRequest方法的 httpResponse = this.mHttpStack.performRequest(request, e);这句，就是将刚才通过HttpURLConnection得到的response返回给httpResponse，然后会一步一步执行到responseContents1 = this.entityToBytes(httpResponse.getEntity());这句，这里就是会去获取之前connection的inputStream输入流，根据输入流来获取byte[]数组，responseContents1 是个byte[]类型，然后将这个byte[]和其他一些信息封装到NetworkResponse这个类型中返回该类型的实例，具体可以细细读BasicNetwork的performRequest方法，接下来我们再回到NetworkDispatcher的run方法的 NetworkResponse e = this.mNetwork.performRequest(request);这句，我们得到response之后就要做解析成我们所要的数据了， Response response = request.parseNetworkResponse(e);比如有String类型或者Image类型或者JSON类型甚至可以自定义成XML类型等等，同时会将数据封装在Entry这个类型里面，这个类型前面一篇讲过的，然后会根据这个request是否需要缓存来对Entry进行缓存 this.mCache.put(request.getCacheKey(), response.cacheEntry);这句就是将Entry里面的数据包括主要的信息和一些Header信息写到cache的file里面，一旦缓存完了就要执行repsonse的派发了 this.mDelivery.postResponse(request, response);这个应该很熟悉了，上篇讲过的，方式跟cache的消息派发是一样的，都是回调主线程的request的Response.Listener和Response.ErrorListener，这里就不贴源码了，上篇说过的，忘了可以回看下吧。好了，关于网络请求的部分讲完了，关于Volley框架的核心功能部分基本就讲完了，其实讲的也是非常重要的主干部分，如果有时间有精力可以再去看看其他部分的细节，比如Volley框架关于图片缓存技术的自定义，Volley框架实现自定义的Request请求，Volley框架将网络层的HttpStack换成Okhttp框架，Volley里面的byte数组的缓存池等等，如果有时间和精力我再去写写这些方面的东西。
扫一扫
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
