深入解读Android的Volley库的功能结构

git clone https://android.googlesource.com/platform/frameworks/volley

public static requestqueue newrequestqueue(context context) {
 return newrequestqueue(context, null);
}

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) {
 stack = new hurlstack();
 } else {
 // prior to gingerbread, httpurlconnection was unreliable.
 // see: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
 stack = new httpclientstack(androidhttpclient.newinstance(useragent));
 }
 }

 network network = new basicnetwork(stack);

 requestqueue queue = new requestqueue(new diskbasedcache(cachedir), network);
 queue.start();

 return queue;
}

//重复的请求将加入这个集合
private final map<string, queue<request>> mwaitingrequests =
 new hashmap<string, queue<request>>();
//所有正在处理的请求任务的集合 
private final set<request> mcurrentrequests = new hashset<request>();
//缓存任务的队列
private final priorityblockingqueue<request> mcachequeue =
 new priorityblockingqueue<request>();
//网络请求队列
private final priorityblockingqueue<request> mnetworkqueue =
 new priorityblockingqueue<request>();
//默认线程池大小
private static final int default_network_thread_pool_size = 4;
//用于响应数据的存储与获取
private final cache mcache;
//用于网络请求
private final network mnetwork;
//用于分发响应数据
private final responsedelivery mdelivery;
//网络请求调度
private networkdispatcher[] mdispatchers;
//缓存调度
private cachedispatcher mcachedispatcher;

public requestqueue(cache cache, network network) {
 this(cache, network, default_network_thread_pool_size);
}
public requestqueue(cache cache, network network, int threadpoolsize) {
 this(cache, network, threadpoolsize,
 new executordelivery(new handler(looper.getmainlooper())));
}
public requestqueue(cache cache, network network, int threadpoolsize,
 responsedelivery delivery) {
 mcache = cache;
 mnetwork = network;
 mdispatchers = new networkdispatcher[threadpoolsize];
 mdelivery = delivery;
}

public void start() {
 stop(); // make sure any currently running dispatchers are stopped.
 // create the cache dispatcher and start it.
 mcachedispatcher = new cachedispatcher(mcachequeue, mnetworkqueue, mcache, mdelivery);
 mcachedispatcher.start();

 // create network dispatchers (and corresponding threads) up to the pool size.
 for (int i = 0; i < mdispatchers.length; i++) {
 networkdispatcher networkdispatcher = new networkdispatcher(mnetworkqueue, mnetwork,
 mcache, mdelivery);
 mdispatchers[i] = networkdispatcher;
 networkdispatcher.start();
 }
}

public request add(request request) {
 // tag the request as belonging to this queue and add it to the set of current requests.
 request.setrequestqueue(this);
 synchronized (mcurrentrequests) {
 mcurrentrequests.add(request);
 }

 // process requests in the order they are added.
 request.setsequence(getsequencenumber());
 request.addmarker("add-to-queue");

 // if the request is uncacheable, skip the cache queue and go straight to the network.
 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)) {
 // there is already a request in flight. queue up.
 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;
 }
}

public void run() {
 if (debug) volleylog.v("start new dispatcher");
 process.setthreadpriority(process.thread_priority_background);

 // make a blocking call to initialize the cache.
 mcache.initialize();

 while (true) {
 try {
 // get a request from the cache triage queue, blocking until
 // at least one is available. 取出缓存队列的任务
 final request request = mcachequeue.take();
 request.addmarker("cache-queue-take");

 // if the request has been canceled, don't bother dispatching it.
 if (request.iscanceled()) {
 request.finish("cache-discard-canceled");
 continue;
 }

 // attempt to retrieve this item from cache.
 cache.entry entry = mcache.get(request.getcachekey());
 if (entry == null) {
 request.addmarker("cache-miss");
 // cache miss; send off to the network dispatcher.
 mnetworkqueue.put(request);
 continue;
 }

 // if it is completely expired, just send it to the network.
 if (entry.isexpired()) {
 request.addmarker("cache-hit-expired");
 request.setcacheentry(entry);
 mnetworkqueue.put(request);
 continue;
 }

 // we have a cache hit; parse its data for delivery back to the request.
 request.addmarker("cache-hit");
 response<?> response = request.parsenetworkresponse(
  new networkresponse(entry.data, entry.responseheaders));
 request.addmarker("cache-hit-parsed");

 if (!entry.refreshneeded()) {
 // completely unexpired cache hit. just deliver the 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.
 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) {
 // we may have been interrupted because it was time to quit.
 if (mquit) {
 return;
 }
 continue;
 }
 }
}

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) {
 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()) {
 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));
 }
 }
}

public void postresponse(request<?> request, response<?> response) {
 postresponse(request, response, null);
}
public void postresponse(request<?> request, response<?> response, runnable runnable) {
 request.markdelivered();
 request.addmarker("post-response");
 mresponseposter.execute(new responsedeliveryrunnable(request, response, runnable));
}

private final executor mresponseposter;

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);
 }
 };