学习内容：
1.NetWorkDispatcher网络请求线程调度...
2.NetWork网络请求抽象类...
3.BasicNetWork网络请求抽象类的具体实现...
4.NetWorkResponse接收网络请求返回的响应...
5.ResponseDelivery请求分配抽象类...
6.ExecutorDelivery请求分配的具体实现类...
上一章说完了缓存请求线程调度，那么现在就说一下网络请求线程调度是如何来完成的，网络请求线程调度也是有一个核心过程的，从网络上获取数据信息的过程， 首先从网络请求队列取出请求，如果请求存在，那么对请求进行相关的处理，如果没有请求，那么线程进入等待状态，取出请求之后需要先对请求是否已经被中途取 消进行相关的判断，如果已经请求已经被中途中断，那么结束这次的处理过程，如果没有取消，那么执行请求，获取服务器的返回数据，然后对返回的响应是够是 304响应进行相关的判断，如果是304响应，那么直接也结束对请求的处理。
304请求表示的是相同请求已经被服务器响应，并且返回了已经返回了相关的数据，由于服务器的状态是高并发的执行状态，有可能在同一时间段对两种或几种相同的请求进行相关的处理，那么对于这样多种相同的请求，服务器只需要响应一次数据就可以了，剩下的由ResponseDelivery去分发给所有与之相同的请求就可以了...也就是说服务器对于同一时间段的多个相同的请求只需要响应一次...
如果不是304响应，那么表示这次请求是一个新的请求，那么我们需要向服务器发送请求来获取服务器的响应，最后通过是否进行缓存进行判断之后，一个请求就可以被分发出去了...
1.NetWorkDispatcher.java
1.1 变量的定义
private final BlockingQueue<Request> mQueue; //请求队列...
/** The network interface for processing requests. */
private final Network mNetwork; //网络请求对象，用于执行网络请求工作
/** The cache to write to. */
private final Cache mCache; //缓存对象，用于缓存数据
/** For posting responses and errors. */
private final ResponseDelivery mDelivery; //用于分发请求...
/** Used for telling us to die. */
private volatile boolean mQuit = false; // 用于关闭线程...
1.2 NetWorkDispatcher构造函数...
网络请求线程调度对象的初始化过程...构造函数比较简单，没什么说的...
public NetworkDispatcher(BlockingQueue<Request> queue,
Network network, Cache cache,
ResponseDelivery delivery) {
mQueue = queue;
mNetwork = network;
mCache = cache;
mDelivery = delivery;
}
1.3 public void run(){}
run()方法，线程中最重要的方法，必须要继承的...整个方式就如同刚开始介绍的一样，从请求队列中取出请求，然后判断请求是否被中断，中断就结束处理，没有中断就发送请求，然后对服务器是否已经对这次请求返回了响应数据，如果服务器已经响应了与之相同的请求，那么就停止对这次请求的处理，由分发响应函数去处理，如果是一个新的请求，那么需要定义一个请求对象，然后发送...最后获取到服务器响应后，对响应进行分发...
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //设置线程优先级...
Request request;
while (true) {
try {
// Take a request from the queue.
request = mQueue.take(); //取出请求...
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
} try {
request.addMarker("network-queue-take");//添加标识符.. // If the request was cancelled already, do not perform the
// network request.
if (request.isCanceled()) { //如果请求被中途取消...
request.finish("network-discard-cancelled"); 添加标识符...
continue;
} // Tag the request (if API >= 14)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) { //如果API>=10，那么为请求设置标签...
TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
} // Perform the network request.
NetworkResponse networkResponse = mNetwork.performRequest(request); //发送请求获取服务器的响应...
request.addMarker("network-http-complete"); // If the server returned 304 AND we delivered a response already,
// we're done -- don't deliver a second identical response.
if (networkResponse.notModified && request.hasHadResponseDelivered()) { //如果这个请求是没有改变..说白了就是请求如果是相同的...那么服务器就返回一次响应...其他的通过Delivery去分发就行了...
request.finish("not-modified");
continue;
} // Parse the response here on the worker thread.
Response<?> response = request.parseNetworkResponse(networkResponse);//如果是一个新的请求，那么就需要新建一个请求对象...
request.addMarker("network-parse-complete"); // Write to cache if applicable.
// TODO: Only update cache metadata instead of entire record for 304s.
//如果请求允许被缓存，并且响应的数据不为空...那么将这次请求放入到缓存中..
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry); //放入的操作...
request.addMarker("network-cache-written");
} // Post the response back.
request.markDelivered(); //确认请求要被分发...
mDelivery.postResponse(request, response); 发送请求...
} catch (VolleyError volleyError) {
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) { //如果出现了错误，那么把错误发送...
VolleyLog.e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
}
}
}
//一个错误处理函数，当发生解析请求或者是分发请求时出现错误时进行调用...
private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
error = request.parseNetworkError(error);
mDelivery.postError(request, error);
}
上面涉及到了执行请求...以及分发服务器响应，但是是如何实现的呢？我们先看如何去执行一个请求...
2.NetWork.java
NetWork.java是一个抽象的接口...对外提供一个执行请求方法的接口，方便其他类去实现...
package com.android.volley; /**
* An interface for performing requests.
*/
public interface Network {
/**
* Performs the specified request.
* @param request Request to process
* @return A {@link NetworkResponse} with data and caching metadata; will never be null
* @throws VolleyError on errors
*/
public NetworkResponse performRequest(Request<?> request) throws VolleyError;
}
3.BasicNetWork.java
BasicNetWork是实现NetWork的具体抽象类，是如何执行请求的一个具体过程，其中内部也封装了一些其他方法...
3.1 变量的定义
这几个变量的定义相对比较抽象，但是会在下面细说...
protected static final boolean DEBUG = VolleyLog.DEBUG; //用于Volley内部调试..
private static int SLOW_REQUEST_THRESHOLD_MS = 3000;//对于缓慢的请求定义了一个请求时间...
private static int DEFAULT_POOL_SIZE = 4096; //Int值，用于以后的获取网络数据...
protected final HttpStack mHttpStack; //Http请求栈...
protected final ByteArrayPool mPool; //ByteArrayPool对象...
3.2 public BasicNetWork(){}
构造函数...构造函数构造了一个保存Http请求栈，以及一个获取网络数据对象...
public BasicNetwork(HttpStack httpStack) {
// If a pool isn't passed in, then build a small default pool that will give us a lot of
// benefit and not use too much memory.
this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE)); //调用下面函数..
}
/**
* @param httpStack HTTP stack to be used
* @param pool a buffer pool that improves GC performance in copy operations
*/
//建立一个BasicNetWork对象，这个对象保存了一个请求栈区，另一个参数用于获取数据而建立的对象...
public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
mHttpStack = httpStack;
mPool = pool;
}
3.3 public NetworkResponse performRequest(Request<?> request) throws VolleyError {}
至关重要的方法，用于执行请求，这里我们也可以看到，请求传递的参数并没有写死，而是使用了泛型的方式形成了良好的扩展，也即是说传递过来的请求是什么类型，那么就执行什么类型的请求...
@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
long requestStart = SystemClock.elapsedRealtime(); //获取请求开始的时间，用于调试...
while (true) {
HttpResponse httpResponse = null; //请求响应对象...
byte[] responseContents = null; //请求内容对象...
Map<String, String> responseHeaders = new HashMap<String, String>(); //map集合，用于保存数据报的Header中的数据..
try {
// Gather headers.
Map<String, String> headers = new HashMap<String, String>(); //用于保存缓存下来的Header...缓存的Header一般包含服务响应的整体时间，缓存新鲜度验证等属性值...
addCacheHeaders(headers, request.getCacheEntry()); //添加请求头部的过程...
httpResponse = mHttpStack.performRequest(request, headers);//执行请求，获取响应..
StatusLine statusLine = httpResponse.getStatusLine();//获取响应状态...
int statusCode = statusLine.getStatusCode();//获取状态码.. responseHeaders = convertHeaders(httpResponse.getAllHeaders());//获取响应后的Header中的所有数据...
// Handle cache validation.
//对304响应的一个判断过程，如果是304响应，那么直接走缓存，从缓存获取数据...
if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry().data, responseHeaders, true);
} // Some responses such as 204s do not have content. We must check.
if (httpResponse.getEntity() != null) {//判断响应是否是204判断，由于204响应时不返回数据信息的...因此需要判断...
responseContents = entityToBytes(httpResponse.getEntity()); //如果存在内容，那么通过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 != HttpStatus.SC_OK && statusCode != HttpStatus.SC_NO_CONTENT) {
throw new IOException(); //如果请求状态出现错误，那么抛出异常...
}
return new NetworkResponse(statusCode, responseContents, responseHeaders, false); //如果请求不是304请求，并且上面异常情况也没有发生，那么返回新的请求中的内容+头部以及状态码...
} 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);//url异常...
} catch (IOException e) {//IO异常的处理...
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);//获取响应...
//请求需要进行验证，或者是需要授权异常处理...
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);
}
}
}
}
这个函数涉及了其他几个函数...
3.4 private void logSlowRequests(long requestLifetime, Request<?> request,byte[] responseContents, StatusLine statusLine) {}
记录一个请求——响应的时间超出了预先设置的缓慢请求时间，那么需要进行记录...记录响应码，响应内容等等函数比较的简单...
private void logSlowRequests(long requestLifetime, Request<?> request,
byte[] responseContents, StatusLine statusLine) {
if (DEBUG || requestLifetime > SLOW_REQUEST_THRESHOLD_MS) {
VolleyLog.d("HTTP response for request=<%s> [lifetime=%d], [size=%s], " +
"[rc=%d], [retryCount=%s]", request, requestLifetime,
responseContents != null ? responseContents.length : "null",
statusLine.getStatusCode(), request.getRetryPolicy().getCurrentRetryCount());
}
3.5 private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) {}
添加请求的请求头部，从缓存当中获取头部信息添加到这次请求...
private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) {
// If there's no cache entry, we're done.
if (entry == null) { //缓存数据为空...直接return
return;
}
if (entry.etag != null) {
headers.put("If-None-Match", entry.etag); //返回新鲜度验证标志..
}
if (entry.serverDate > 0) {
Date refTime = new Date(entry.serverDate); //返回请求——响应的时间...
headers.put("If-Modified-Since", DateUtils.formatDate(refTime));
}
}
3.6 private static void attemptRetryOnException(String logPrefix, Request<?> request,VolleyError exception) throws VolleyError {}
尝试重试策略方法...如果请求发生了异常...
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));
}
3.7 private static Map<String, String> convertHeaders(Header[] headers) {}
上面涉及到了当响应返回的时候需要获取响应数据报的Header，将所有的Header数据获取并保存...以键值对的形式保存在map集合当中...最后传递给responseHeaders集合...
private static Map<String, String> convertHeaders(Header[] headers) {
Map<String, String> result = new HashMap<String, String>();
for (int i = 0; i < headers.length; i++) {
result.put(headers[i].getName(), headers[i].getValue());
}
return result;
}
3.8 private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError {}
当Http请求响应成功时，我们需要从HttpEntity中获取返回的内容数据...数据的获取调用此函数..这个函数采用了PoolingArrayByteOutputStream()流..这个流采用了字节回收机制，可以减少内存的分配和回收...我们先知道就行...后面还会具体说明...
private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError {
PoolingByteArrayOutputStream bytes =
new PoolingByteArrayOutputStream(mPool, (int) entity.getContentLength()); //新建一个流对象..
byte[] buffer = null; //缓冲字节..
try {
InputStream in = entity.getContent();//将Entity中保存的内容封装成流...
if (in == null) {
throw new ServerError();
}
buffer = mPool.getBuf(1024); //缓冲流分配...首先new一个缓冲字节数组...
int count;
while ((count = in.read(buffer)) != -1) {
bytes.write(buffer, 0, count); //写入数据...
}
return bytes.toByteArray();//返回数据..
} finally {
try {
// Close the InputStream and release the resources by "consuming the content".
entity.consumeContent();
} catch (IOException e) {
// This can happen if there was an exception above that left the entity in
// an invalid state.
VolleyLog.v("Error occured when calling consumingContent");
}
mPool.returnBuf(buffer);
bytes.close();
}
}
这样总体就完成了请求之后响应数据的获取，也就是数据报的Header+Body的数据被保存了起来...那么完成了数据的获取，就需要响应数据的分发了...分发到请求才是请求——响应的一个最终完成过程...
4.NetWorkResponse.java
那么响应的传递就需要通过NetWorkResponse来进行传递，无论是从网络上获取的请求数据，还是从缓存当中获取的请求数据，都会被封装成NetWorkResponse，然后传递给相应请求中的parseNetWorkResponse方法，在进行下一步的处理...
package com.android.volley; import org.apache.http.HttpStatus; import java.util.Collections;
import java.util.Map; /**
* Data and headers returned from {@link Network#performRequest(Request)}.
*/
public class NetworkResponse {
//对服务器的响应进行一个彻底封装...
public NetworkResponse(int statusCode, byte[] data, Map<String, String> headers,
boolean notModified) {
this.statusCode = statusCode;
this.data = data;
this.headers = headers;
this.notModified = notModified;
}
//构造函数..用来调用第一个构造函数,传递过来的响应只包含数据部分...
public NetworkResponse(byte[] data) {
this(HttpStatus.SC_OK, data, Collections.<String, String>emptyMap(), false);
}
//第二个构造函数，通过响应的数据和相关头部来调用第一个构造函数...
public NetworkResponse(byte[] data, Map<String, String> headers) {
this(HttpStatus.SC_OK, data, headers, false);
} /** The HTTP status code. */
public final int statusCode; //响应状态码... /** Raw data from this response. */
public final byte[] data; //响应数据... /** Response headers. */
public final Map<String, String> headers; //以键值对的形式保存首部.. /** True if the server returned a 304 (Not Modified). */
public final boolean notModified; //304响应的判断...
}
NetWorkResponse只是对服务器的响应的一个进一步封装，以参数的形式传递到Request.parseNetWorkResponse()方法...如果中间并么有出现什么异常情况，那么最后相应实现了Request.parseNetWorkResponse类会调用Response.success方法，将这次请求进行最后的封装，封装成Response<T>的形式，请求是什么类型，T就是什么类型...
5.Response.java
package com.android.volley;
public class Response<T> {
/** Callback interface for delivering parsed responses. */
public interface Listener<T> {
/** Called when a response is received. */
public void onResponse(T response); //当一个请求——相应成功后的监听...
}
/** Callback interface for delivering error responses. */
public interface ErrorListener {
/**
* Callback method that an error has been occurred with the
* provided error code and optional user-readable message.
*/
public void onErrorResponse(VolleyError error); //当请求出现了错误时,需要监听错误..
}
/** Returns a successful response containing the parsed result. */
public static <T> Response<T> success(T result, Cache.Entry cacheEntry) {
return new Response<T>(result, cacheEntry); //success方法，当请求被解析成功时调用的方法...
}
/**
* Returns a failed response containing the given error code and an optional
* localized message displayed to the user.
*/
public static <T> Response<T> error(VolleyError error) {
return new Response<T>(error); //如果解析请求时失败需要封装错误...
}
/** Parsed response, or null in the case of error. */
public final T result; //响应返回的结果..
/** Cache metadata for this response, or null in the case of error. */
public final Cache.Entry cacheEntry; //缓存...
/** Detailed error information if <code>errorCode != OK</code>. */
public final VolleyError error; //一个错误对象...记录错误的生成...
/** True if this response was a soft-expired one and a second one MAY be coming. */
public boolean intermediate = false; //判断一个请求是否失效...
/**
* Returns whether this response is considered successful.
*/
public boolean isSuccess() {
return error == null; //如果成功就没有错误传递...
}
private Response(T result, Cache.Entry cacheEntry) { //对成功时封装的构造函数...
this.result = result;
this.cacheEntry = cacheEntry;
this.error = null;
}
private Response(VolleyError error) {/失败时封装的构造函数...
this.result = null;
this.cacheEntry = null;
this.error = error;
}
}
当响应被封装成Response之后，就需要向客户端发送响应了，通过postResponse方法进行发送，如果一个响应成功，我们需要发送响应，但是如果中途出现了失败，那么我们需要把错误发送，需要让客户端清楚到底是发生了什么错误，这样在错误发生时提示用户到底应该怎样进行操作...
6.ResponseDelivery.java
解析响应之后的发送类，只是一个抽象的接口，我们可以人为去重写如何发送响应...而系统默认则采用线程池的方式对响应进行发送...
package com.android.volley;
public interface ResponseDelivery {
/**
* Parses a response from the network or cache and delivers it.
*/
public void postResponse(Request<?> request, Response<?> response); //对响应进行发送...
/**
* Parses a response from the network or cache and delivers it. The provided
* Runnable will be executed after delivery.
*/
public void postResponse(Request<?> request, Response<?> response, Runnable runnable); //对响应发送，同时开启一个线程去执行其他事情...线程在这个方法结束后执行...
/**
* Posts an error for the given request.
*/
public void postError(Request<?> request, VolleyError error); //发送错误信息...
}
7.ExecutorDelivery.java
发送请求或者是错误的具体实现类，采用线程池的方式对响应进行发送...无论是服务器响应正确还是错误，我们都需要对其进行封装发送给客户端，让客户端去清楚服务器到底返回了什么东西...
package com.android.volley;
import android.os.Handler;
import java.util.concurrent.Executor;
public class ExecutorDelivery implements ResponseDelivery {
/** Used for posting responses, typically to the main thread. */
private final Executor mResponsePoster; //定义一个线程池...
//定义了一个Response的传输接口...
public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
}
};
}
//构造函数，定义了一个线程池...
public ExecutorDelivery(Executor executor) {
mResponsePoster = executor;
}
//发送请求的抽象方法的实现...
@Override
public void postResponse(Request<?> request, Response<?> response) {
postResponse(request, response, null);
}
/*最后都是通过调用此方法来发送请求，因为poseResponse的方法有两种
* 一种是public void postResponse(Request<?> request, Response<?> response);
* 另一种是 public void postResponse(Request<?> request, Response<?> response, Runnable runnable);
*这两个方法上面已经说过，就是一个带有一个附加线程，一个没有而已...
*但最终都需要调用这个方法...
*/
@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered(); //表示可以发送请求...
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable)); //用线程封装好Response..通过线程池的方式去管理这些线程...从这一步开始run()方法已经被调用了...
}
//如果出现了错误，那么将错误封装，同时也要发送给请求的客户端...
@Override
public void postError(Request<?> request, VolleyError error) {
request.addMarker("post-error");
Response<?> response = Response.error(error); //封装错误..
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, null)); //发送错误...
}
@SuppressWarnings("rawtypes")
private class ResponseDeliveryRunnable implements Runnable {
private final Request mRequest; //请求
private final Response mResponse; //响应
private final Runnable mRunnable; //其他线程...
//构造函数非常的简单..对三者的一个封装过程...
public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
mRequest = request;
mResponse = response;
mRunnable = runnable;
}
//run方法...
@SuppressWarnings("unchecked")
@Override
public void run() {
// If this request has canceled, finish it and don't deliver.
if (mRequest.isCanceled()) { //如果请求被中断，那么就不需要发送响应了...
mRequest.finish("canceled-at-delivery");
return;
}
// Deliver a normal response or error, depending.
if (mResponse.isSuccess()) { //如果服务器响应成功，中途没有错误的发生,,,
mRequest.deliverResponse(mResponse.result);//将服务器返回的结果发送给客户端...这是最后的关键地方...
} else {
mRequest.deliverError(mResponse.error);//如果其中出现了失败，需要把错误发送...
}
// If this is an intermediate response, add a marker, otherwise we're done
// and the request can be finished.
//这里不知道该如何理解...翻译成中间响应...
if (mResponse.intermediate) {
mRequest.addMarker("intermediate-response"); //如果是需要进行调试过程...
} else {
mRequest.finish("done");//如果不是表示这次请求结束...
}
// If we have been provided a post-delivery runnable, run it.
if (mRunnable != null) { //如果附加线程不是空，那么就启动附加线程..
mRunnable.run();
}
}
}
}
我们可以看到，最后服务器的响应被封装之后，通过mRequest.deliveryResponse或者是mRequest.deliveryerror进行发送...而这两个方法就会在相应类型的请其中得到重写...因为所有的其他请求都是继承Request类的...Request类中只是一个抽象的方法，具体的实现在那些实际实现了Request的类中...而每一个实现类中都会去调用mListener.onResponse(response)方法，这里只表示请求成功时调用的方法...
abstract protected void deliverResponse(T response);
public interface Listener<T> {
/** Called when a response is received. */
public void onResponse(T response);
}
这样在客户端重写OnResponse方法之后，就彻底的完成了请求——响应的结束过程...数据也就成功的从服务器通过网络成功的发送给了客户端...