Volley学习笔记（一） Volley学习笔记（一）

【Volley学习笔记（一）】2019独角兽企业重金招聘Python工程师标准>>>
文章图片

Volley简介 volley是谷歌在2013年I/O大会上提出的一个网络通讯框架，简单易用，可扩展性强，通过查看源码你就会发现他有好多接口设计模式，极大的方便开发者去调用。它内部还实现了图片加载的功能。它主要适合一些数据量不大，但是通讯频繁的网络操作。但是对于一些大数据量，比如文件上传下载，Volley的表现可能会让你失望。
贴一张它的总体设计图：

文章图片

Volley使用 Volley的使用是很简单的，大体来讲只需要三步：
new 一个全局的RequestQuene 消息队列；
new 一个request对象；
把request对象add到RequestQuene 消息队列中。
这里就不贴代码了。关于它的使用随便搜索就能找一大把，下面主要学习他的源码。
Volley源码 Volley.java 这个类是对外暴漏的一个API，用于创建一个消息队列。

public class Volley { /** Default on-disk cache directory. */ private static final String DEFAULT_CACHE_DIR = "volley"; /** * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it. *获取Volley对象 * @param context A {@link Context} to use for creating the cache dir. * @param stack An {@link HttpStack} to use for the network, or null for default. * @return A started {@link RequestQueue} instance. */ @SuppressLint("NewApi") 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; /* * 实例化一个RequestQueue，其中start()主要完成相关工作线程的开启， * 比如开启缓存线程CacheDispatcher先完成缓存文件的扫描，还包括开启多个NetworkDispatcher访问网络线程， * 该多个网络线程将从同一个网络阻塞队列中读取消息 * * 此处可见，start()已经开启，所有我们不用手动的去调用该方法，在start()方法中如果存在工作线程应该首先终止，并重新实例化工作线程并开启 * 在访问网络很频繁，而又重复调用start()，势必会导致性能的消耗；但是如果在访问网络很少时，调用stop()方法，停止多个线程，然后调用start(),反而又可以提高性能，具体可折中选择 */ } /** * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it. * * @param context A {@link Context} to use for creating the cache dir. * @return A started {@link RequestQueue} instance. */ public static RequestQueue newRequestQueue(Context context) { return newRequestQueue(context, null); } }

代码比较简单，里面有两个newRequestQueue重载方法
public static RequestQueue newRequestQueue(Context context) ｛｝
public static RequestQueue newRequestQueue(Context context, HttpStack stack) ｛｝
第一个的时候内部调用了第二个方法，切给第二个参数传null。看第二个方法，首先初始化了一个文件地址，也就是缓存的地址。
关于userAgent
Volley首先自定义了一个默认的userAgent，在不抛出异常的情况下会使用包名+版本号，通过下面代码可以看到如果SDK<9也就是使用HttpClient的时候，就会使用userAgent。HttpUrlconnection不需要设置userAgent，他是固定的。Volley设置userAgent是为了自定义Header。
关于HttpClient和HttpURLConnection
Volley里面在SDK大于9就会使用HttpURLConnection，低于9就会使用HttpClient。他俩有什么区别呢？HttpURLConnection在SDK小于9，也就是Android 2.2以前，存在重大的bug，调用close()函数会影响连接池，导致连接复用失败。Android 2.3以后增加了gzip压缩和请求结果缓存。所以2.3以后还是使用HttpURLConnection。
接着下面会实例化两个对象Network、DiskBasedCache并作为参数初始化RequestQueue，最后调用queue.start()方法。Network是用于进行网络请求的一个接口，他的实现类是BasicNetwork；DiskBasedCache则是从缓存查找结果的实现类。后面再看这两个类的具体实现。先看下start（）方法的源码。
RequestQueue.java 这个类是它的核心类之一，实现了把请求放进请求队列的add方法。

/** * A request dispatch queue with a thread pool of dispatchers. * * Calling {@link #add(Request)} will enqueue the given Request for dispatch, * resolving from either cache or network on a worker thread, and then delivering * a parsed response on the main thread. * RequestQueue类存在2个非常重要的PriorityBlockingQueue类型的成员字段mCacheQueue mNetworkQueue ，该PriorityBlockingQueue为java1.5并发库提供的新类 * 其中有几个重要的方法，比如take()为从队列中取得对象，如果队列不存在对象，将会被阻塞，直到队列中存在有对象，类似于Looper.loop() * * 实例化一个request对象，调用RequestQueue.add(request),该request如果不允许被缓存，将会被添加至mNetworkQueue队列中，待多个NetworkDispatcher线程take()取出对象 * 如果该request可以被缓存，该request将会被添加至mCacheQueue队列中，待mCacheDispatcher线程从mCacheQueue.take()取出对象， * 如果该request在mCache中不存在匹配的缓存时，该request将会被移交添加至mNetworkQueue队列中，待网络访问完成后，将关键头信息添加至mCache缓存中去！ */ public class RequestQueue { /** Used for generating monotonically-increasing sequence numbers for requests. */ private AtomicInteger mSequenceGenerator = new AtomicInteger(); /** * Staging area for requests that already have a duplicate request in flight. * * *containsKey(cacheKey) indicates that there is a request in flight for the given cache *key. *get(cacheKey) returns waiting requests for the given cache key. The in flight request *is not contained in that list. Is null if no requests are staged. * */ private final Map>> mWaitingRequests = new HashMap>>(); /** * The set of all requests currently being processed by this RequestQueue. A Request * will be in this set if it is waiting in any queue or currently being processed by * any dispatcher. */ private final Set> mCurrentRequests = new HashSet>(); /** The cache triage queue. * 缓存队列 * */ private final PriorityBlockingQueue> mCacheQueue = new PriorityBlockingQueue>(); /** The queue of requests that are actually going out to the network. * 网络队列 * */ private final PriorityBlockingQueue> mNetworkQueue = new PriorityBlockingQueue>(); /** Number of network request dispatcher threads to start. */ private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4; /** Cache interface for retrieving and storing responses. */ private final Cache mCache; /** Network interface for performing requests. */ private final Network mNetwork; /** Response delivery mechanism. */ private final ResponseDelivery mDelivery; /** The network dispatchers. */ private NetworkDispatcher[] mDispatchers; /** The cache dispatcher. */ private CacheDispatcher mCacheDispatcher; /** * Creates the worker pool. Processing will not begin until {@link #start()} is called. * * @param cache A Cache to use for persisting responses to disk * @param network A Network interface for performing HTTP requests * @param threadPoolSize Number of network dispatcher threads to create * @param delivery A ResponseDelivery interface for posting responses and errors */ public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) { mCache = cache; mNetwork = network; mDispatchers = new NetworkDispatcher[threadPoolSize]; mDelivery = delivery; } /** * Creates the worker pool. Processing will not begin until {@link #start()} is called. * * @param cache A Cache to use for persisting responses to disk * @param network A Network interface for performing HTTP requests * @param threadPoolSize Number of network dispatcher threads to create */ public RequestQueue(Cache cache, Network network, int threadPoolSize) { this(cache, network, threadPoolSize, new ExecutorDelivery(new Handler(Looper.getMainLooper()))); } /** * Creates the worker pool. Processing will not begin until {@link #start()} is called. * * @param cache A Cache to use for persisting responses to disk * @param network A Network interface for performing HTTP requests */ public RequestQueue(Cache cache, Network network) { this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE); } /** * Starts the dispatchers in this queue. * 如果该request可以被缓存，该request将会被添加至mCacheQueue队列中，待mCacheDispatcher线程从mCacheQueue.take()取出对象， * 如果该request在mCache中不存在匹配的缓存时，该request将会被移交添加至mNetworkQueue队列中，待网络访问完成后，将关键头信息添加至mCache缓存中去！ */ 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(); } } /** * Stops the cache and network dispatchers. */ public void stop() { if (mCacheDispatcher != null) { mCacheDispatcher.quit(); } for (int i = 0; i < mDispatchers.length; i++) { if (mDispatchers[i] != null) { mDispatchers[i].quit(); } } } /** * Gets a sequence number. */ public int getSequenceNumber() { return mSequenceGenerator.incrementAndGet(); } /** * Gets the {@link Cache} instance being used. */ public Cache getCache() { return mCache; } /** * A simple predicate or filter interface for Requests, for use by * {@link RequestQueue#cancelAll(RequestFilter)}. */ public interface RequestFilter { public boolean apply(Request request); } /** * Cancels all requests in this queue for which the given filter applies. * @param filter The filtering function to use */ public void cancelAll(RequestFilter filter) { synchronized (mCurrentRequests) { for (Request request : mCurrentRequests) { if (filter.apply(request)) { request.cancel(); } } } } /** * Cancels all requests in this queue with the given tag. Tag must be non-null * and equality is by identity. */ public void cancelAll(final Object tag) { if (tag == null) { throw new IllegalArgumentException("Cannot cancelAll with a null tag"); } cancelAll(new RequestFilter() { @Override public boolean apply(Request request) { return request.getTag() == tag; } }); } /** * Adds a Request to the dispatch queue. * 将请求添加到队列中 * @param request The request to service * @return The passed-in request */ 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> stagedRequests = mWaitingRequests.get(cacheKey); if (stagedRequests == null) { stagedRequests = new LinkedList>(); } 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; } } /** * Called from {@link Request#finish(String)}, indicating that processing of the given request * has finished. * * Releases waiting requests for request.getCacheKey() if *request.shouldCache(). */ void finish(Request request) { // Remove from the set of requests currently being processed. synchronized (mCurrentRequests) { mCurrentRequests.remove(request); }if (request.shouldCache()) { synchronized (mWaitingRequests) { String cacheKey = request.getCacheKey(); Queue> waitingRequests = mWaitingRequests.remove(cacheKey); if (waitingRequests != null) { if (VolleyLog.DEBUG) { VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.", waitingRequests.size(), cacheKey); } // Process all queued up requests. They won't be considered as in flight, but // that's not a problem as the cache has been primed by 'request'. mCacheQueue.addAll(waitingRequests); } } } } }

start()方法主要作用是启动了一个CacheDispatcher和四个NetworkDispatcher，即一个缓存分发线程和四个网络请求分发线程，他们两个都是继承自Thread的，四个网络线程是可配置的，可以根据自己的需求更改。
add()方法是把请求放进队列的方法。放进请求后会给request设置一个序列号和标志，然后根据request.shouldCache()判断如果为false则加入mNetworkQueue网络请求队列，默认是不允许缓存的。然后判断是否在等待队列中，则继续排队等待。如果不在则放进mCacheQueue。
看下两个队列吧，两个队列是PriorityBlockingQueue类型的，这个类型是JAVA1.5提供的新类，可以通过调用他的take方法取出里面的对象，如果不存在则队列阻塞，直到有对象。它里面存储的对象必须是实现Comparable接口的，request就实现了Comparable接口，一会再看。还有几个队列的类，一起看一下：
ArrayBlockingQueue：一个由数组支持的有界阻塞队列。使用时需要指定大小。
LinkedBlockingQueue：基于链表实现的阻塞队列，使用时不需要指定大小,，他是无界的。他的排序原则是先进先出。
SynchronousQueue：他也是一个无界的队列。他的特性是必须等待前面的线程取走以后才会添加下一个。newCachedThreadPool()就是基于这样一个队列。
RequestQueue这个类里面还有其他的finish,cancel方法实现了对请求的关闭和取消，这里就不细讲了。
Request.java 这个类是网络请求的抽象类，Volley里面的StringRequest、JsonRequest都是他的子类。

/** * Base class for all network requests. * * @param The type of parsed response this request expects. */ public abstract class Request implements Comparable> {/** * Default encoding for POST or PUT parameters. See {@link #getParamsEncoding()}. */ private static final String DEFAULT_PARAMS_ENCODING = "UTF-8"; /** * Supported request methods. */ public interface Method { int DEPRECATED_GET_OR_POST = -1; int GET = 0; int POST = 1; int PUT = 2; int DELETE = 3; int HEAD = 4; int OPTIONS = 5; int TRACE = 6; int PATCH = 7; }/** An event log tracing the lifetime of this request; for debugging. */ private final MarkerLog mEventLog = MarkerLog.ENABLED ? new MarkerLog() : null; /** * Request method of this request.Currently supports GET, POST, PUT, DELETE, HEAD, OPTIONS, * TRACE, and PATCH. */ private final int mMethod; /** URL of this request. */ private final String mUrl; /** The redirect url to use for 3xx http responses */ private String mRedirectUrl; /** Default tag for {@link TrafficStats}. */ private final int mDefaultTrafficStatsTag; /** Listener interface for errors. */ private final Response.ErrorListener mErrorListener; /** Sequence number of this request, used to enforce FIFO ordering. */ private Integer mSequence; /** The request queue this request is associated with. */ private RequestQueue mRequestQueue; /** Whether or not responses to this request should be cached. */ private boolean mShouldCache = true; /** Whether or not this request has been canceled. */ private boolean mCanceled = false; /** Whether or not a response has been delivered for this request yet. */ private boolean mResponseDelivered = false; // A cheap variant of request tracing used to dump slow requests. private long mRequestBirthTime = 0; /** Threshold at which we should log the request (even when debug logging is not enabled). */ private static final long SLOW_REQUEST_THRESHOLD_MS = 3000; /** The retry policy for this request. */ private RetryPolicy mRetryPolicy; /** * When a request can be retrieved from cache but must be refreshed from * the network, the cache entry will be stored here so that in the event of * a "Not Modified" response, we can be sure it hasn't been evicted from cache. */ private Cache.Entry mCacheEntry = null; /** An opaque token tagging this request; used for bulk cancellation. */ private Object mTag; /** * Creates a new request with the given 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. * * @deprecated Use {@link #Request(int, String, com.android.volley.Response.ErrorListener)}. */ @Deprecated public Request(String url, Response.ErrorListener listener) { this(Method.DEPRECATED_GET_OR_POST, url, listener); }/** * 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); }/** * Return the method for this request.Can be one of the values in {@link Method}. */ public int getMethod() { return mMethod; }/** * Set a tag on this request. Can be used to cancel all requests with this * tag by {@link RequestQueue#cancelAll(Object)}. * * @return This Request object to allow for chaining. */ public Request setTag(Object tag) { mTag = tag; return this; }/** * Returns this request's tag. * @see Request#setTag(Object) */ public Object getTag() { return mTag; }/** * @return A tag for use with {@link TrafficStats#setThreadStatsTag(int)} */ public int getTrafficStatsTag() { return mDefaultTrafficStatsTag; }/** * @return The hashcode of the URL's host component, or 0 if there is none. */ private static int findDefaultTrafficStatsTag(String url) { if (!TextUtils.isEmpty(url)) { Uri uri = Uri.parse(url); if (uri != null) { String host = uri.getHost(); if (host != null) { return host.hashCode(); } } } return 0; }/** * Sets the retry policy for this request. * * @return This Request object to allow for chaining. */ public Request setRetryPolicy(RetryPolicy retryPolicy) { mRetryPolicy = retryPolicy; return this; }/** * Adds an event to this request's event log; for debugging. */ public void addMarker(String tag) { if (MarkerLog.ENABLED) { mEventLog.add(tag, Thread.currentThread().getId()); } else if (mRequestBirthTime == 0) { mRequestBirthTime = SystemClock.elapsedRealtime(); } }/** * Notifies the request queue that this request has finished (successfully or with error). * * Also dumps all events from this request's event log; for debugging. */ void finish(final String tag) { if (mRequestQueue != null) { mRequestQueue.finish(this); } if (MarkerLog.ENABLED) { final long threadId = Thread.currentThread().getId(); if (Looper.myLooper() != Looper.getMainLooper()) { // If we finish marking off of the main thread, we need to // actually do it on the main thread to ensure correct ordering. Handler mainThread = new Handler(Looper.getMainLooper()); mainThread.post(new Runnable() { @Override public void run() { mEventLog.add(tag, threadId); mEventLog.finish(this.toString()); } }); return; }mEventLog.add(tag, threadId); mEventLog.finish(this.toString()); } else { long requestTime = SystemClock.elapsedRealtime() - mRequestBirthTime; if (requestTime >= SLOW_REQUEST_THRESHOLD_MS) { VolleyLog.d("%d ms: %s", requestTime, this.toString()); } } }/** * Associates this request with the given queue. The request queue will be notified when this * request has finished. * * @return This Request object to allow for chaining. */ public Request setRequestQueue(RequestQueue requestQueue) { mRequestQueue = requestQueue; return this; }/** * Sets the sequence number of this request.Used by {@link RequestQueue}. * * @return This Request object to allow for chaining. */ public final Request setSequence(int sequence) { mSequence = sequence; return this; }/** * Returns the sequence number of this request. */ public final int getSequence() { if (mSequence == null) { throw new IllegalStateException("getSequence called before setSequence"); } return mSequence; }/** * Returns the URL of this request. */ public String getUrl() { return (mRedirectUrl != null) ? mRedirectUrl : mUrl; }/** * Returns the URL of the request before any redirects have occurred. */ public String getOriginUrl() { return mUrl; }/** * Sets the redirect url to handle 3xx http responses. */ public void setRedirectUrl(String redirectUrl) { mRedirectUrl = redirectUrl; }/** * Returns the cache key for this request.By default, this is the URL. */ public String getCacheKey() { return getUrl(); }/** * Annotates this request with an entry retrieved for it from cache. * Used for cache coherency support. * * @return This Request object to allow for chaining. */ public Request setCacheEntry(Cache.Entry entry) { mCacheEntry = entry; return this; }/** * Returns the annotated cache entry, or null if there isn't one. */ public Cache.Entry getCacheEntry() { return mCacheEntry; }/** * Mark this request as canceled.No callback will be delivered. */ public void cancel() { mCanceled = true; }/** * Returns true if this request has been canceled. */ public boolean isCanceled() { return mCanceled; }/** * Returns a list of extra HTTP headers to go along with this request. Can * throw {@link AuthFailureError} as authentication may be required to * provide these values. * @throws AuthFailureError In the event of auth failure */ public Map getHeaders() throws AuthFailureError { return Collections.emptyMap(); }/** * Returns a Map of POST parameters to be used for this request, or null if * a simple GET should be used.Can throw {@link AuthFailureError} as * authentication may be required to provide these values. * * Note that only one of getPostParams() and getPostBody() can return a non-null * value. * @throws AuthFailureError In the event of auth failure * * @deprecated Use {@link #getParams()} instead. */ @Deprecated protected Map getPostParams() throws AuthFailureError { return getParams(); }/** * Returns which encoding should be used when converting POST parameters returned by * {@link #getPostParams()} into a raw POST body. * * This controls both encodings: * *The string encoding used when converting parameter names and values into bytes prior *to URL encoding them. *The string encoding used when converting the URL encoded parameters into a raw *byte array. * * * @deprecated Use {@link #getParamsEncoding()} instead. */ @Deprecated protected String getPostParamsEncoding() { return getParamsEncoding(); }/** * @deprecated Use {@link #getBodyContentType()} instead. */ @Deprecated public String getPostBodyContentType() { return getBodyContentType(); }/** * Returns the raw POST body to be sent. * * @throws AuthFailureError In the event of auth failure * * @deprecated Use {@link #getBody()} instead. */ @Deprecated public byte[] getPostBody() throws AuthFailureError { // Note: For compatibility with legacy clients of volley, this implementation must remain // here instead of simply calling the getBody() function because this function must // call getPostParams() and getPostParamsEncoding() since legacy clients would have // overridden these two member functions for POST requests. Map postParams = getPostParams(); if (postParams != null && postParams.size() > 0) { return encodeParameters(postParams, getPostParamsEncoding()); } return null; }/** * Returns a Map of parameters to be used for a POST or PUT request.Can throw * {@link AuthFailureError} as authentication may be required to provide these values. * * Note that you can directly override {@link #getBody()} for custom data. * * @throws AuthFailureError in the event of auth failure */ protected Map getParams() throws AuthFailureError { return null; }/** * Returns which encoding should be used when converting POST or PUT parameters returned by * {@link #getParams()} into a raw POST or PUT body. * * This controls both encodings: * *The string encoding used when converting parameter names and values into bytes prior *to URL encoding them. *The string encoding used when converting the URL encoded parameters into a raw *byte array. * */ protected String getParamsEncoding() { return DEFAULT_PARAMS_ENCODING; }public String getBodyContentType() { return "application/x-www-form-urlencoded; charset=" + getParamsEncoding(); }/** * Returns the raw POST or PUT body to be sent. * * @throws AuthFailureError in the event of auth failure */ public byte[] getBody() throws AuthFailureError { Map params = getParams(); if (params != null && params.size() > 0) { return encodeParameters(params, getParamsEncoding()); } return null; }/** * Converts params into an application/x-www-form-urlencoded encoded string. */ private byte[] encodeParameters(Map params, String paramsEncoding) { StringBuilder encodedParams = new StringBuilder(); try { for (Map.Entry entry : params.entrySet()) { encodedParams.append(URLEncoder.encode(entry.getKey(), paramsEncoding)); encodedParams.append('='); encodedParams.append(URLEncoder.encode(entry.getValue(), paramsEncoding)); encodedParams.append('&'); } return encodedParams.toString().getBytes(paramsEncoding); } catch (UnsupportedEncodingException uee) { throw new RuntimeException("Encoding not supported: " + paramsEncoding, uee); } }/** * Set whether or not responses to this request should be cached. * * @return This Request object to allow for chaining. */ public final Request setShouldCache(boolean shouldCache) { mShouldCache = shouldCache; return this; }/** * Returns true if responses to this request should be cached. */ public final boolean shouldCache() { return mShouldCache; }/** * Priority values.Requests will be processed from higher priorities to * lower priorities, in FIFO order. */ public enum Priority { LOW, NORMAL, HIGH, IMMEDIATE }/** * Returns the {@link Priority} of this request; {@link Priority#NORMAL} by default. */ public Priority getPriority() { return Priority.NORMAL; }/** * Returns the socket timeout in milliseconds per retry attempt. (This value can be changed * per retry attempt if a backoff is specified via backoffTimeout()). If there are no retry * attempts remaining, this will cause delivery of a {@link TimeoutError} error. */ public final int getTimeoutMs() { return mRetryPolicy.getCurrentTimeout(); }/** * Returns the retry policy that should be usedfor this request. */ public RetryPolicy getRetryPolicy() { return mRetryPolicy; }/** * Mark this request as having a response delivered on it.This can be used * later in the request's lifetime for suppressing identical responses. */ public void markDelivered() { mResponseDelivered = true; }/** * Returns true if this request has had a response delivered for it. */ public boolean hasHadResponseDelivered() { return mResponseDelivered; }/** * Subclasses must implement this to parse the raw network response * and return an appropriate response type. This method will be * called from a worker thread.The response will not be delivered * if you return null. * @param response Response from the network * @return The parsed response, or null in the case of an error */ abstract protected Response parseNetworkResponse(NetworkResponse response); /** * Subclasses can override this method to parse 'networkError' and return a more specific error. * * The default implementation just returns the passed 'networkError'. * * @param volleyError the error retrieved from the network * @return an NetworkError augmented with additional information */ protected VolleyError parseNetworkError(VolleyError volleyError) { return volleyError; }/** * Subclasses must implement this to perform delivery of the parsed * response to their listeners.The given response is guaranteed to * be non-null; responses that fail to parse are not delivered. * @param response The parsed response returned by * {@link #parseNetworkResponse(NetworkResponse)} */ abstract protected void deliverResponse(T response); /** * Delivers error message to the ErrorListener that the Request was * initialized with. * * @param error Error details */ public void deliverError(VolleyError error) { if (mErrorListener != null) { mErrorListener.onErrorResponse(error); } }/** * Our comparator sorts from high to low priority, and secondarily by * sequence number to provide FIFO ordering. */ @Override public int compareTo(Request 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(); }@Override public String toString() { String trafficStatsTag = "0x" + Integer.toHexString(getTrafficStatsTag()); return (mCanceled ? "[X] " : "[ ] ") + getUrl() + " " + trafficStatsTag + " " + getPriority() + " " + mSequence; } }

首先他实现了Comparable接口并实现了compareTo的方法，通过上面的RequestQueue的介绍，实现Comparable是为了设置请求的优先级。优先级高的就会排在前面，优先级相等的情况会按照添加RequestQueue时设置的序列号，按照先进先出排序。
Volley 支持 8 种 Http 请求方式 GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, PATCH。Request 类中包含了请求 url，请求请求方式，请求 Header，请求 Body，请求的优先级等信息。
既然是抽象类，有两个子类必须实现的方法：
abstract protected Response parseNetworkResponse(NetworkResponse response);
子类重写此方法，将网络返回的原生字节内容，转换成合适的类型。此方法会在工作线程中被调用。
abstract protected void deliverResponse(T response);
子类重写此方法，将解析成合适类型的内容传递给它们的监听回调。
public byte[] getBody() throws AuthFailureError｛｝
重写此方法，可以构建用于 POST、PUT、PATCH 请求方式的 Body 内容。

转载于:https://my.oschina.net/tomcater/blog/681007