在上一篇，流行网络库第（一）篇—Volley用法解析中了解了Volley的基本使用，但是对于Volley可能有些朋友还不是特别清楚。我也是结合源码与其他人的分析，才真正弄清楚Volley的工作原理。
先看一个Demo，Volley十几行代码就完成了一次HTPP请求，我们看看这段代码内部究竟发生了什么？
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
RequestQueue mQueue = Volley.newRequestQueue(MainActivity.this);
mQueue.add(getStringRequest());
}
public StringRequest getStringRequest() {
return new StringRequest("https://suggest.taobao.com/sug?code=utf-8&q=beizi",
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.e(getClass().getName(), response);
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
Log.e(getClass().getName(), error.getMessage());
}
}
);
}
}首先第一句代码，创建一个消息队列
RequestQueue mQueue = Volley.newRequestQueue(MainActivity.this);
创建消息队列的逻辑，被封装在Volley中，以静态方法暴露出来，供外部调用，总共有3个重载方法，上面使用的是第一个方法（只有一个参数），第一个方法会调用第二个方法（两个参数），第二个方法会调用第三个方法（三个参数）。
public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, null);
}
public static RequestQueue newRequestQueue(Context context, HttpStack stack){
return newRequestQueue(context, stack, -1);
}
public static RequestQueue newRequestQueue(Context context, int maxDiskCacheBytes) {
return newRequestQueue(context, null, maxDiskCacheBytes);
}现在看第三个构造方法中做了什么？，这是第一个重点。
public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
//应用的默认缓存目录，DEFAULT_CACHE_DIR值是volley,即文件cacheDir的文件名是volley
File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
// 通过应用程序的包名和版本信息来完善userAgent字符串
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}
//如果stack为NULL,就建立一个默认的HttpStack
if (stack == null) {
if (Build.VERSION.SDK_INT >= 9) {
//版本在2.3之后，创建HurlStack，其内部用了HttpURLConnection
stack = new HurlStack();
} else {
//版本在2.3之前，创建HttpClientStack，其内部用了HttpClient
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
//将stack传到Network中，Network是负责网络请求的
Network network = new BasicNetwork(stack);
RequestQueue queue;
//创建RequestQueue时要传入一个Cache对象，用来做磁盘缓存
if (maxDiskCacheBytes <= -1) {
// No maximum size specified
queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
} else{
// Disk cache size specified
queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
}
// 开始请求队列
queue.start();
return queue;
}注释都写清楚了，主要就是在创建请求队列的时候，做一些初始化的工作。
- 1、创建应用缓存目录，这个目录是volley；
- 2、 通过应用程序的包名和版本信息来完善userAgent字符串，这个userAgent只有在使用HttpClientStack才有用到；
- 3、如果用户没有建立stack，就建立一个默认的Stack，这里根据版本号判断使用 HttpURLConnection还是使用HttpClient创建Stack；
- 4、创建Stack的目的是作为参数创建Network，Network是负责网络请求的；
- 5、有了Network和DiskBasedCache，最后创建消息队列并且开启消息队列。
到这里你可能还不知道，做这些初始化操作的目的是什么，继续看。
看到最后返回的是RequestQueue对象，我们现在看RequestQueue是怎么工作的。先看看RequestQueue里面几个重要的成员变量。
public class RequestQueue {
//等待队列，当之前已经存在了与本次请求相同的请求时，会把相同的请求放在队列中，以URL为关键字（key）
private final Map<String, Queue<Request<?>>> mWaitingRequests =
new HashMap<String, Queue<Request<?>>>();
//存放所有请求，包括已经运行的和正在等待的请求（Request）
private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
//表示目前缓存的请求队列，这个队列会被传入到CacheDispatcher做判断。
private final PriorityBlockingQueue<Request<?>> mCacheQueue =
new PriorityBlockingQueue<Request<?>>();
//表示请求网络连接的队列，里面的请求都会向服务器进行请求（这才是唯一和服务器打交道的队列）。
private final PriorityBlockingQueue<Request<?>> mNetworkQueue =
new PriorityBlockingQueue<Request<?>>();
// Volley类中调用的构造函数，传入了默认的网络线程数，DEFAULT_NETWORK_THREAD_POOL_SIZE = 4（默认是4个线程）
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
//缓存相关
private final Cache mCache;
//网络请求相关
private final Network mNetwork;
//请求结果分发器，会把响应得到的结果发送到主线程的回调方法中，最终传递给监听器。
private final ResponseDelivery mDelivery;
//阻塞式线程数组，不断循环处理Request。
private NetworkDispatcher[] mDispatchers;
//阻塞式线程，不断循环处理Request。
private CacheDispatcher mCacheDispatcher;
//请求完成时的监听数组
private List<RequestFinishedListener> mFinishedListeners =
new ArrayList<RequestFinishedListener>();
public static interface RequestFinishedListener<T> {
public void onRequestFinished(Request<T> request);
}
}
上面的成员变量代表的意思，请看注释，现在看如何创建一个RequestQueue。这是第二个重点。
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
//初始化了network，dispatchers，delivery，cache对象，这里的cache是磁盘缓存的对象
//初始化完成后，立刻调用了start()方法
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
public RequestQueue(Cache cache, Network network) {
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
}
public void start() {
//先停止两个阻塞式线程
stop();
//创建一个缓存线程（缓存分发器），不断的处理Request
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
//创建4个网络线程（网络分发器），不断的处理Request
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
//停止5个阻塞式线程，一个缓存线程，4个网络线程
public void stop() {
if (mCacheDispatcher != null) {
mCacheDispatcher.quit();
}
for (int i = 0; i < mDispatchers.length; i++) {
if (mDispatchers[i] != null) {
mDispatchers[i].quit();
}
}
}现在看看，其实
RequestQueue mQueue = Volley.newRequestQueue(MainActivity.this);这一行代码，原来做了这么多的事情，用最后两行代码来概括
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir),network);
queue.start();就是创建了一个RequestQueue对象，调用start对象，开启了4个线程，同时我们要记清楚，RequestQueue并不是一个简单的Queue，内部有好几个Queue，其中mCurrentRequests 存放所有请求，包括已经运行的和正在等待的请求；mCacheQueue （Request）表示目前缓存的请求队列，这个队列会被传入到CacheDispatcher做判断；mNetworkQueue 表示请求网络连接的队列，里面的请求都会向服务器进行请求（这才是唯一和服务器打交道的队列）。并且RequestQueue中还创建了5个线程，其中CacheDispatcher是缓存线程，数量为1，NetworkDispatcher是网络线程，存放在mDispatchers中，数量默认为4。
RequestQueue准备好了，现在该看看，往里面add了。这是第三个重点。
mQueue.add(getStringRequest());add方法如下
public <T> Request<T> add(Request<T> request) {
//每个request的内部维持着一个RequestQueue,先给内部维持的RequestQueue赋值
request.setRequestQueue(this);
synchronized (mCurrentRequests) {
//mCurrentRequests中保存了所有的request，所以一上来就添加
mCurrentRequests.add(request);
}
//设置request的序列号
request.setSequence(getSequenceNumber());
// 设置request当前的真正进行的事件，标记现在是被添加到队列中了
request.addMarker("add-to-queue");
// 如果不允许有磁盘缓存，跳过mCacheQueue，直接把request添加到networkQueue中，然后去请求网络
if (!request.shouldCache()) {
// 添加到mNetworkQueue中，进行网络交互
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there's already a request with the same cache key in flight.
//mWaitingRequests保存了当前正在执行的请求与等待的请求
synchronized (mWaitingRequests) {
//这个cacheKey是请求的url和请求方式Method拼接起来的，保证了Key的唯一性
String cacheKey = request.getCacheKey();
// 判断等待队列中是否已经有这个request，如果有了就需要过滤重复请求
if (mWaitingRequests.containsKey(cacheKey)) {
// There is already a request in flight. Queue up.
// mWaitingRequests的类型是HashMap<String, Queue<Request<?>>>
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<Request<?>>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
} else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
请注意mWaitingRequests，mWaitingRequests的类型是HashMap
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();
}
}所以我们看一下，当一个request已经添加到了mWaitingRequests中了，缓存线程mCacheDispatcher是怎么处理它的。注意CacheDispatcher接收了mCacheQueue, mNetworkQueue, mCache, mDelivery这些参数。
先看看CacheDispatcher类的成员。
public class CacheDispatcher extends Thread {
private static final boolean DEBUG = VolleyLog.DEBUG;
//缓存队列
private final BlockingQueue<Request<?>> mCacheQueue;
//网路请求队列
private final BlockingQueue<Request<?>> mNetworkQueue;
/** The cache to read from. */
private final Cache mCache;
//将响应分发到主线程
private final ResponseDelivery mDelivery;
/** Used for telling us to die. */
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;
}
}主要看CacheDispatcher线程中的run方法，这是第四个重点。
@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// 初始化缓存区，就把之前文件中所保存的对象，一个一个读出来，保存在Map<String, CacheHeader> mEntries这个变量中
mCache.initialize();
Request<?> request;
while (true) {
// release previous request object to avoid leaking request object when mQueue is drained.
request = null;
try {
// 从cache队列中取出一个request对象
request = mCacheQueue.take();
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
try {
// 设置当前事件名称，标记缓存队列中取出的
request.addMarker("cache-queue-take");
// 如果这个request已经被取消了，就直接finish掉，进行下一次循环
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
//上面缓存区已经被初始化，所以可以从缓冲区中取出一个缓存，从mCache内部维持的mEntries中取
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
// 设置当前事件名称
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
//加入到mNetworkQueue中，进行网络请求，进行下一次循环，处理下一次request
mNetworkQueue.put(request);
continue;
}
// entry不为null,但是已经完全过期了，让它重新访问网络
// If it is completely expired, just send it to the network.
if (entry.isExpired()) {
//设置当前事件名称，标记缓存命中且过期
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
//加入到mNetworkQueue中，进行下一次循环，处理下一次request
mNetworkQueue.put(request);
continue;
}
//设置当前事件名称，标记缓存命中
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
//设置当前事件名称，标记这个request已经被解析了
request.addMarker("cache-hit-parsed");
// 判断是否需要刷新
if (!entry.refreshNeeded()) {
// 发送到response中
mDelivery.postResponse(request, response);
} else {
// Soft-expired cache hit. We can deliver the cached response,
// but we need to also send the request to the network for
// refreshing.
//设置当前事件名称，标记缓存需要刷新
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);
// Mark the response as intermediate.
response.intermediate = true;
// Post the intermediate response back to the user and have
// the delivery then forward the request along to the network.
final Request<?> finalRequest = request;
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(finalRequest);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
}
}
}经过一系列的操作得到的request,最终会把一个request解析成一个Response,调用的是parseNetworkResponse方法。不同的request有不同的parseNetworkResponse方法，我们最上面的Demo用的是StringRequest。
@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));
}得到了Response之后，将这个Response交给mDelivery，mDelivery称为数据分发器，最开始由构造函数传进来的。关于数据的分发，这是第五个重点。
mDelivery.postResponse(request, response);在RequestQueue构造中，mDelivery被初始化，是个ExecutorDelivery对象。
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}ExecutorDelivery是个接口，继承ResponseDelivery
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);
}ExecutorDelivery内部有一个Runnable,/用于分发网络的响应结果到主线程的，这是第六个重点。
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;
}
@SuppressWarnings("unchecked")
@Override
public void run() {
// 看看是否已经被取消了，如果被取消了，结束它，不做分发处理
if (mRequest.isCanceled()) {
//设置当前事件名称，标记request被取消
mRequest.finish("canceled-at-delivery");
return;
}
// 分发一个的响应结果
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 {
//设置当前事件名称，标记request已经完成
mRequest.finish("done");
}
// If we have been provided a post-delivery runnable, run it.
if (mRunnable != null) {
mRunnable.run();
}
}
}mListener，mErrorListener就是我们Demo中设置的回调接口。
@Override
protected void deliverResponse(String response) {
if (mListener != null) {
mListener.onResponse(response);
}
} public void deliverError(VolleyError error) {
if (mErrorListener != null) {
mErrorListener.onErrorResponse(error);
}
}现在再看那张图
其中蓝色部分代表主线程，绿色部分代表缓存线程，橙色部分代表网络线程。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。
Volley工作流程总结：http://www.cnblogs.com/tianzhijiexian/p/4264468.html
1. 当一个RequestQueue被成功申请后会开启一个CacheDispatcher（缓存调度器）和4个（默认）NetworkDispatcher（网络请求调度器）；
2. CacheDispatcher缓存调度器最为第一层缓冲，开始工作后阻塞的从缓存序列mCacheQueue中取得请求：
a. 对于已经取消了的请求，直接标记为跳过并结束这个请求
b. 全新或过期的请求，直接丢入mNetworkQueue中交由N个NetworkDispatcher进行处理
c. 已获得缓存信息（网络应答）却没有过期的请求，交由Request的parseNetworkResponse进行解析，从而确定此应答是否成功。然后将请求和应答交由Delivery分发者进行处理，如果需要更新缓存那么该请求还会被放入mNetworkQueue中
3. 用户将请求Request add到RequestQueue之后：
a. 对于不需要缓存的请求（需要额外设置，默认是需要缓存）直接丢入mNetworkQueue交由N个NetworkDispatcher处理；
b. 对于需要缓存的，全新的请求加入到mCacheQueue中给CacheDispatcher处理
c. 需要缓存，但是缓存列表中已经存在了相同URL的请求，放在mWaitingQueue中做暂时雪藏，待之前的请求完毕后，再重新添加到mCacheQueue中；
4. 网络请求调度器NetworkDispatcher作为网络请求真实发生的地方，对消息交给BasicNetwork进行处理，同样的，请求和结果都交由Delivery分发者进行处理；
5. Delivery分发者实际上已经是对网络请求处理的最后一层了，在Delivery对请求处理之前，Request已经对网络应答进行过解析，此时应答成功与否已经设定。而后Delivery根据请求所获得的应答情况做不同处理：
a. 若应答成功，则触发deliverResponse方法，最终会触发开发者为Request设定的Listener
b. 若应答失败，则触发deliverError方法，最终会触发开发者为Request设定的ErrorListener
处理完后，一个Request的生命周期就结束了，Delivery会调用Request的finish操作，将其从mRequestQueue中移除，与此同时，如果等待列表中存在相同URL的请求，则会将剩余的层级请求全部丢入mCacheQueue交由CacheDispatcher进行处理。
一个Request的生命周期：
1. 通过add加入mRequestQueue中，等待请求被执行；
2. 请求执行后，调用自身的parseNetworkResponse对网络应答进行处理，并判断这个应答是否成功；
3. 若成功，则最终会触发自身被开发者设定的Listener；若失败，最终会触发自身被开发者设定的ErrorListener。
参考链接：
http://www.cnblogs.com/tianzhijiexian/p/4264468.html
http://blog.csdn.net/guolin_blog/article/details/17656437
http://blog.csdn.net/ttdevs/article/details/17764351
扫一扫
665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
