Volley源码分析

纠错   27 Aug 2015

//这个waitingRequest是因为用户可能重复提交了相同的请求，第一次提交一个请求后
//会在这个Map里添加一个key,表示这个请求已经在处理了，如果再提交相同的请求就会
//把这个请求添加到这个key对应的请求队列里，并把第一次的请求加入到缓存队列里，
//后面再发出这个请求就可以从缓存中获取响应了
 private final Map<String, Queue<Request<?>>> mWaitingRequests =
		new HashMap<String, Queue<Request<?>>>();
//用来存储当前所有的请求
private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
//这是个优先队列，存储那些需要缓存的请求，处理这类请求时，先从缓存中查询，
//如果缓存miss再把它丢进networkRequest中从网络中获取数据  
private final PriorityBlockingQueue<Request<?>> mCacheQueue =
		new PriorityBlockingQueue<Request<?>>();
//这个队列用于存储需要直接从网络中获取数据的请求
private final PriorityBlockingQueue<Request<?>> mNetworkQueue =
		new PriorityBlockingQueue<Request<?>>();

public enum Priority {
        LOW,
	NORMAL,
	HIGH,
	IMMEDIATE
}

@Override
public int compareTo(Request<T> other) {
Priority left = this.getPriority();
Priority right = other.getPriority();

// High-priority requests are "lesser" so they are sorted to the front.
// Equal priorities are sorted by sequence number to provide FIFO ordering.
return left == right ?
        this.mSequence - other.mSequence :
        right.ordinal() - left.ordinal();
}

if (stack == null) {
    if (Build.VERSION.SDK_INT >= 9) {
	stack = new HurlStack();
    } else {
	stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
    }
}

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
    // self-defined user agent
    Map<String, String> headerMap = new HashMap<String, String>();
    headerMap.put("User-Agent", "android-open-project-analysis/1.0");
    return headerMap;
}

private List<byte[]> mBuffersByLastUse = new LinkedList<byte[]>();
private List<byte[]> mBuffersBySize = new ArrayList<byte[]>(64);

private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) {
	// If there's no cache entry, we're done.
	if (entry == null) {
	    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));
	}
    }

public static Cache.Entry parseCacheHeaders(NetworkResponse response) {
long now = System.currentTimeMillis();

Map<String, String> headers = response.headers;

long serverDate = 0;
long serverExpires = 0;
long softExpire = 0;
long maxAge = 0;
boolean hasCacheControl = false;

String serverEtag = null;
String headerValue;

headerValue = headers.get("Date");
if (headerValue != null) {
    serverDate = parseDateAsEpoch(headerValue);
}

headerValue = headers.get("Cache-Control");
if (headerValue != null) {
    hasCacheControl = true;
    String[] tokens = headerValue.split(",");
    for (int i = 0; i < tokens.length; i++) {
        String token = tokens[i].trim();
        if (token.equals("no-cache") || token.equals("no-store")) {
            return null;
        } else if (token.startsWith("max-age=")) {
            try {
                maxAge = Long.parseLong(token.substring(8));
            } catch (Exception e) {
            }
        } else if (token.equals("must-revalidate") || token.equals("proxy-revalidate")) {
            maxAge = 0;
        }
    }
}

headerValue = headers.get("Expires");
if (headerValue != null) {
    serverExpires = parseDateAsEpoch(headerValue);
}

serverEtag = headers.get("ETag");

// Cache-Control takes precedence over an Expires header, even if both exist and Expires
// is more restrictive.
if (hasCacheControl) {
    softExpire = now + maxAge * 1000;
} else if (serverDate > 0 && serverExpires >= serverDate) {
    // Default semantic for Expire header in HTTP specification is softExpire.
    softExpire = now + (serverExpires - serverDate);
}

Cache.Entry entry = new Cache.Entry();
entry.data = response.data;
entry.etag = serverEtag;
entry.softTtl = softExpire;
entry.ttl = entry.softTtl;
entry.serverDate = serverDate;
entry.responseHeaders = headers;

return entry;
}