标签：
临近毕业，各种事情各种忙。我也没有认真专注写过博客，最近仔细看了Volley框架的使用及其源码，思前想后，想挑战一下自己，还是写一篇博客来分享，如有错误，欢迎吐槽。
网络请求是一个App很重要的一部分，android系统只是提供了一个平台，而android应用则是基于这个平台上进行展示数据，起到与用户进行交互的作用，数据来源于服务端，而二者之间必须通过互联网进行传输数据，在Android系统发布初期，很多开发者都是在Apache协会的Http协议的基础上进行网络请求方法的封装，当然有小白和大神，难免会出现一些意想不到的问题。谷歌也是考虑到了这一点，在2013年I/O大会上发布了一个基于HttpURLConnection的网络请求框架–Volley。
Volley把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。
Volley适用于请求一些数据量不大且频繁的数据，不适合请求一些大数据。
Volley的使用方法可以看郭神的博客 ，在此我们就直接分析源码了。
我们知道Volley所有的请求都是基于Request这个抽象类，我们来看看这个类中的主要方法：
/**
* Creates a new request with the given method (one of the values from {@link Method}),
* URL, and error listener. Note that the normal response listener is not provided here as
* delivery of responses is provided by subclasses, who have a better idea of how to deliver
* an already-parsed response.
*/
public Request(int method, String url, Response.ErrorListener listener) {
mMethod = method;
mUrl = url;
mErrorListener = listener;
setRetryPolicy(new DefaultRetryPolicy());
mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);
}这里Request的构造方法，没什么特别，就是把传入的参数传递给对应的对象，以及设置了一个请求的优先级，这里为默认。
abstract protected Response<T> parseNetworkResponse(NetworkResponse response);
这是Request中最主要的两个方法之一，每个继承的类都必须具体实现这两个方法。parseNetworkResponse方法中response是最后服务端返回的字节码数据之后在子线程中被调用，进行解析数据，我们可以将这个字节码数据转换成我们想要的类型，比如StringRequest中，parseNetworkResponse方法的实现如下：
@Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
String parsed;
try {
parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
} catch (UnsupportedEncodingException e) {
parsed = new String(response.data);
}
return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}很明显，这个将字节码以指定的编码格式转换成了String字符串。
abstract protected void deliverResponse(T response);看着方法名就可以知道，这个是将最后解析过的请求数据交付给主线程，让主线程进行处理，还记得我们在构造函数中传入一个Listener的对象吗，对，就是它。我们可以通过接口回调的方式将最终数据返回给主线程使用。还是一样，我们看看StringRequest中的实现：
@Override
protected void deliverResponse(String response) {
mListener.onResponse(response);
}Request抽象类中还有一些其他的属性，比如：
public Request<?> setTag(Object tag) {
mTag = tag;
return this;
}给每个Request附加一个标签，便于管理。
public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {
mRetryPolicy = retryPolicy;
return this;
}设置一个自定义的在请求失败的情况下重新请求的规则。
public void addMarker(String tag) {
if (MarkerLog.ENABLED) {
mEventLog.add(tag, Thread.currentThread().getId());
} else if (mRequestBirthTime == 0) {
mRequestBirthTime = SystemClock.elapsedRealtime();
}
}这个方法主要是打印日志的方式展示请求的过程进度。
/**
* Returns the URL of this request.
*/
public String getUrl() {
return mUrl;
}
/**
* Returns the cache key for this request. By default, this is the URL.
*/
public String getCacheKey() {
return getUrl();
}这里要注意的是把url作为一个缓存的Key。
我们知道我们需要把Request添加到RequestQueue中才能完成网络请求，我们一般通过静态方法
RequestQueue mQueue = Volley.newRequestQueue(MainActivity.this); 那么我们看看RequestQueue的代码：
创建一个RequestQueue对象，
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) {
//sdk版本高于9时，创建一个HrlStack对象，里面是网络请求的具体逻辑
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
//创建一个Network对象，里面进行了网络请求数据方法的二次封装
Network network = new BasicNetwork(stack);
//传入一个缓存对象以及netWork对象
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
//启动队列
queue.start();
return queue;
}可以看出，在这个方法中，最后在创建RequestQueue的时候，传入了一个缓存对象以及封装好的网络请求方法的对象，最后调用一个start方法，现在我们还没有看它的具体实现，但是我们知道现在是万事俱备，只欠东风了。就像一台榨汁机接通了电源并且开启了开关，我们只需要扔进水果就行了。当然，我们这里不能扔进水果…我们需要做的就是：
requestQueue.add(request); 把Request对象加入进去，让它自己去跑，我们已经在Request中两个抽象方法中写好了解析以及最终数据的交付逻辑。我们来看看RequestQueue.add()中的代码：
public <T> Request<T> add(Request<T> request) {
// 在此request设置一个标记，指明此request属于的RequestQueue
request.setRequestQueue(this);
synchronized (mCurrentRequests) {
//将请求添加到队列中
mCurrentRequests.add(request);
}
// 处理请求按顺序添加
request.setSequence(getSequenceNumber());
request.addMarker("add-to-queue");
// 如果request不需要缓存，直接加入mNetworkQueue队列，等待处理
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there‘s already a request with the same cache key in flight.
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
// 等待缓存的队列中已经有了此请求
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<Request<?>>();
}
stagedRequests.add(request);
//将新增加的request的集合对象覆盖进去
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
} else {
//如果等待缓存队列中只有一个请求，那么value的值就为null
mWaitingRequests.put(cacheKey, null);
//将request添加到缓存工作队列中
mCacheQueue.add(request);
}
return request;
}
} 可能一部分读者看到这里就有点晕了，怎么这么多的队列。我们一个个解释。
mCurrentRequests，它的对象声明是这样的：
private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
Set集合中存放的是无序且不重复的子对象。mCurrentRequests 在这里包含了所有我们通过requestQueue.add(request); 方法添加的request，这个集合主要起到管理request的作用，在request请求在NetworkDispatcher线程中处理结束之后，无论请求成功或者失败，都会调用Request的finish方法：
void finish(final String tag) {
if (mRequestQueue != null) {
mRequestQueue.finish(this);
}很明显，Request中调用了mRequestQueue的finish方法，让我们看下代码：
<T> void finish(Request<T> request) {
// Remove from the set of requests currently being processed.
synchronized (mCurrentRequests) {
mCurrentRequests.remove(request);
}从这里我们可以看到，在request响应结束之后，我们将request从mCurrentRequests移除，这里我只贴出了部分代码。
mNetworkQueue和mCacheQueue，它们的声明是这样的：
private final PriorityBlockingQueue<Request<?>> mNetworkQueue =new PriorityBlockingQueue<Request<?>>();
private final PriorityBlockingQueue<Request<?>> mCacheQueue =new PriorityBlockingQueue<Request<?>>();
先来说下PriorityBlockingQueue这个类吧，这个类实现了implements BlockingQueue<E> 这个接口，BlockingQueue是jdk中Concurrent包中新增的用于解决了多线程中，如何高效安全“传输”数据的问题，并且它能保证线程安全。所以将mNetworkQueue和mCacheQueue传入子线程中，让子线程从中获取request进行处理。
mWaitingRequests:
private final Map<String, Queue<Request<?>>> mWaitingRequests =
new HashMap<String, Queue<Request<?>>>();
mWaitingRequests是一个Map集合，里面保存着键值对，以request的url为key。
接着往下我们看`queue.start();`这个方法中的代码：
/**
* Starts the dispatchers in this queue.
*/
public void start() {
stop(); // 如果队列在开启状态，关闭
//创建一个缓存分发线程，并且启动它
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
// 创建多个网络请求的线程，并且启动它们
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}NetworkDispatcher和CacheDispatcher都是继承于Thread类。从上面的源码可知，我们将默认启动是4个子线程，这4个子线程一直在跑，执行RequestQueue中的Request。而mCacheDispatcher只开启一个线程，用于缓存响应数据。
接着我们来看在NetworkDispatcher线程中是如何处理请求的：
public class NetworkDispatcher extends Thread {
/** 需要处理的请求队列 */
private final BlockingQueue<Request<?>> mQueue;
/** 封装好了的用来处理网络请求的接口 */
private final Network mNetwork;
/** 用于写入缓存的对象 */
private final Cache mCache;
/** 用来请求之后的接口回调 */
private final ResponseDelivery mDelivery;
/** 用于退出此线程 */
private volatile boolean mQuit = false;
public NetworkDispatcher(BlockingQueue<Request<?>> queue,
Network network, Cache cache,
ResponseDelivery delivery) {
mQueue = queue;
mNetwork = network;
mCache = cache;
mDelivery = delivery;
}
/**
* 结束此线程
*/
public void quit() {
mQuit = true;
interrupt();
}
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
private void addTrafficStatsTag(Request<?> request) {
//Api>=14以上调用此方法(if API >= 14)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) { TrafficStats.setThreadStatsTag(
request.getTrafficStatsTag());
}
}
@Override
public void run() {
//设置线程为后台线程
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//全真循环，不断获取mQueue中的request进行处理
while (true) {
long startTimeMs = SystemClock.elapsedRealtime();
Request<?> request;
try {
// 获取请求
request = mQueue.take();
} catch (InterruptedException e) {
// 请求超时的时候，结束线程
if (mQuit) {
return;
}
continue;
}
try {
request.addMarker("network-queue-take");
// 请求被取消
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}
addTrafficStatsTag(request);
// 执行请求
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete");
// 如果我们已经递交过同样的响应数据，那么不会再次递交
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}
// 在子线程中解析字节码为我们想要的数据类型
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");
// request需要缓存，并且response的缓存入口不为空
if (request.shouldCache() && response.cacheEntry != null) {
//以request的url为key，以response的缓存入口为value进行缓存
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
//标志已经递交，请求结束
request.markDelivered();
//接口回调
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
}
}
/**
*解析错误的时候，接口回调对应的方法
*/
private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
error = request.parseNetworkError(error);
mDelivery.postError(request, error);
}
} Volley默认是开启四个NetworkDispatcher这个线程，用于不断从mQueue中获取request进行处理请求。以mNetwork为处理器，并且在获取成功之后回调在request中parseNetworkResponse方法进行解析成我们想要的数据。这个方法是不是很熟悉，没错，它就是我们在自定义Request中所要重新的抽象方法之一。在解析失败时也会有相应的接口回调。
在请求需要进行缓存并且响应数据缓存入口不为空的情况下，我们将以request的url为key，以response的缓存入口为value进行缓存。
最后将解析好的数据通过 mDelivery.postResponse(request, response); 方法抛给主线程处理。
CacheDispatcher是一个缓存线程，让我们看看它的代码实现：
public class CacheDispatcher extends Thread {
private static final boolean DEBUG = VolleyLog.DEBUG;
/** 缓存队列*/
private final BlockingQueue<Request<?>> mCacheQueue;
/** 网络请求队列*/
private final BlockingQueue<Request<?>> mNetworkQueue;
/** 缓存对象 */
private final Cache mCache;
/** 用于将最终数据传递的接口*/
private final ResponseDelivery mDelivery;
/** 线程是否存活 */
private volatile boolean mQuit = false;
public CacheDispatcher(
BlockingQueue<Request<?>> cacheQueue, BlockingQueue<Request<?>> networkQueue,
Cache cache, ResponseDelivery delivery) {
mCacheQueue = cacheQueue;
mNetworkQueue = networkQueue;
mCache = cache;
mDelivery = delivery;
}
/**
* 结束线程
*/
public void quit() {
mQuit = true;
interrupt();
}
@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher"); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// 初始化线程对象
mCache.initialize();
//全真循环，不断获取mCacheQueue中的request进行处理
while (true) {
try {
//从mCacheQueue中获取request对象，如果mCacheQueue为空，那么会堵塞暂停，直至mCacheQueue添加了对象
final Request<?> request = mCacheQueue.take();
request.addMarker("cache-queue-take");
// 取消了缓存要求
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
// 获取缓存的条目
Cache.Entry entry =mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// 如果缓存中找不到缓存条目，那么把请求扔mNetworkQueue，让它去通过网络请求数据
mNetworkQueue.put(request);
continue;
}
//如果缓存条目过期的话，那么把request加入mNetworkQueue让它去通过网络重新请求数据
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}
//有了有效的缓存对象，将缓存对象通过Request中定义的解析方法解析成我们想要的数据类型
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
if (!entry.refreshNeeded()) {
// 不需要刷新的数据，可以直接递交给主线程使用了
mDelivery.postResponse(request, response);
} else {
//需要刷新的数据，将它它去通过网络重新请求数据
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);
// 因为只是响应数据需要刷新，所以可以把response作为媒介，标记这个为true
response.intermediate = true;
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}
} catch (InterruptedException e) {
if (mQuit) {
return;
}
continue;
}
}
}
}Volley官网的框架结构流程图：
总结一下：Volley框架中封装了网络请求的具体方法在HurlStack类中，它就相当于一个加载器，BasicNetwork类对它进行了二次封装。CacheDispatcher的目的就是从mCacheQueue中获取request，然后再从缓存中判断是否有对应的缓存，如果没有或者过期等原因，会将此request抛给mNetworkQueue队列，让mNetworkQueue在NetworkDispatcher中，而在NetworkDispatcher中通过获取mNetworkQueue的每个request，使用默认的HurlStack加载器（当然也可以自定义）向服务端请求数据，最后将请求成功的响应数据再进行缓存。
至此。Volley框架的源码算是解析完毕。那么如何在实际开发项目中正确使用它呢，我会在下一篇中叙述。
这是我第一次花这么多心思写博客，花了一下午和一晚上的时间，希望大家能有所收获。
标签：
原文地址：http://blog.csdn.net/kongchengjiumenghx/article/details/51345628
