Volley源碼分析

基本的使用步驟

        // 1, 獲取到請求隊列
        RequestQueue requestQueue = Volley.newRequestQueue(this);
        // 2, 創建一個Request
        StringRequest stringRequest = new StringRequest("", new com.android.volley.Response.Listener<String>() {
            @Override
            public void onResponse(String s) {

            }
        }, new com.android.volley.Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {

            }
        });
        //3,加入請求隊列
        requestQueue.add(stringRequest);

源碼分析

public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, (HttpStack)null);
}
//正在創建的方法
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        File cacheDir = new File(context.getCacheDir(), "volley");
        String userAgent = "volley/0";

        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException var6) {
            ;
        }

        if(stack == null) {
            if(VERSION.SDK_INT >= 9) {
                //創建Http HttpURLConnnect實現
                stack = new HurlStack();
            } else {
              //創建Http HttpClient實現
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }
        //網絡封裝層
        Network network = new BasicNetwork((HttpStack)stack);
        //創建請求隊列
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();
        return queue;
}

//start方法
public void start() {
  this.stop();
  //創建一個CacheDispatcher
  this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
  this.mCacheDispatcher.start();
  //創建多個NetworkDispatcher 默認是4
  for(int i = 0; i < this.mDispatchers.length; ++i) {
        NetworkDispatcher networkDispatcher = new NetworkDispatcher(this.mNetworkQueue, this.mNetwork, this.mCache, this.mDelivery);
        this.mDispatchers[i] = networkDispatcher;
        networkDispatcher.start();
  }
}

** CacheDispatcher 緩存分發器的實現 **

//繼承線程類
public class CacheDispatcher extends Thread
  ...

while(true)
{
  //從緩存隊列裏面去除一個Request
	final Request request = (Request)this.mCacheQueue.take();
	request.addMarker("cache-queue-take");
  //如果請求取消，加入Marker
	if(request.isCanceled()) {
		request.finish("cache-discard-canceled");
	} else {
    //通過CacheKey從緩存去除緩存的數據
		Entry entry = this.mCache.get(request.getCacheKey());
    //下面是一系列異常情況 加入marker
		if(entry == null) {
			request.addMarker("cache-miss");
			this.mNetworkQueue.put(request);
		} else if(entry.isExpired()) {
			request.addMarker("cache-hit-expired");
			request.setCacheEntry(entry);
			this.mNetworkQueue.put(request);
		} else {
			request.addMarker("cache-hit");
      //解析緩存數據
			Response<?> response = request.parseNetworkResponse(new NetworkResponse(entry.data, entry.responseHeaders));
      //下面也是一些異常情況 加入Marker
			request.addMarker("cache-hit-parsed");
			if(entry.refreshNeeded()) {
				request.addMarker("cache-hit-refresh-needed");
				request.setCacheEntry(entry);
				response.intermediate = true;
        //如果需要去刷新最新的數據，加入到網絡隊列裏面
				this.mDelivery.postResponse(request, response, new Runnable() {
					public void run() {
						try {
							CacheDispatcher.this.mNetworkQueue.put(request);
						} catch (InterruptedException var2) {
							;
						}

					}
				});
			} else {
        //直接返回返回的響應
				this.mDelivery.postResponse(request, response);
			}
		}
	}
}

** NetworkDispatcher 緩存分發器的實現 **

//繼承線程類
public class NetworkDispatcher extends Thread

...
//從隊列裏面取出一個request
request = (Request)this.mQueue.take();

{

	request.addMarker("network-queue-take");
	if(request.isCanceled()) {
		request.finish("network-discard-cancelled");
	} else {
		if(VERSION.SDK_INT >= 14) {
			TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
		}
    //從網絡層獲取到網絡請求
		NetworkResponse networkResponse = this.mNetwork.performRequest(request);
		request.addMarker("network-http-complete");
		if(networkResponse.notModified && request.hasHadResponseDelivered()) {
			request.finish("not-modified");
		} else {
      //解析網絡請求
			Response<?> response = request.parseNetworkResponse(networkResponse);
			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();
      //返回響應
			this.mDelivery.postResponse(request, response);
		}
	}

}

** add()方法 **

public Request add(Request request)
{
	request.setRequestQueue(this);
	Set var2 = this.mCurrentRequests;
	synchronized(this.mCurrentRequests) {
		this.mCurrentRequests.add(request);
	}

	request.setSequence(this.getSequenceNumber());
	request.addMarker("add-to-queue");
  //如果請求開啓緩存加入緩存隊列 如果沒有開啓緩存，直接加入網絡請求隊列
	if(!request.shouldCache()) {
		this.mNetworkQueue.add(request);
		return request;
	} else {
		Map var7 = this.mWaitingRequests;
		synchronized(this.mWaitingRequests) {
			String cacheKey = request.getCacheKey();
      //重複性判斷
			if(this.mWaitingRequests.containsKey(cacheKey)) {
				Queue<Request> stagedRequests = (Queue)this.mWaitingRequests.get(cacheKey);
				if(stagedRequests == null) {
					stagedRequests = new LinkedList();
				}

				((Queue)stagedRequests).add(request);
				this.mWaitingRequests.put(cacheKey, stagedRequests);
				if(VolleyLog.DEBUG) {
					VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", new Object[] {cacheKey});
				}
			} else {
				this.mWaitingRequests.put(cacheKey, (Object)null);
				this.mCacheQueue.add(request);
			}
			return request;
		}
	}
}