源码：

1 /*  2  * Copyright (C) 2011 The Android Open Source Project  3  *  4  * Licensed under the Apache License, Version 2.0 (the "License");  5  * you may not use this file except in compliance with the License.  6  * You may obtain a copy of the License at  7  *  8  *      http://www.apache.org/licenses/LICENSE-2.0  9  * 10  * Unless required by applicable law or agreed to in writing, software 11  * distributed under the License is distributed on an "AS IS" BASIS, 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13  * See the License for the specific language governing permissions and 14  * limitations under the License. 15  */ 16  17 package com.android.volley; 18  19 import android.net.TrafficStats; 20 import android.net.Uri; 21 import android.os.Handler; 22 import android.os.Looper; 23 import android.text.TextUtils; 24 import com.android.volley.VolleyLog.MarkerLog; 25  26 import java.io.UnsupportedEncodingException; 27 import java.net.URLEncoder; 28 import java.util.Collections; 29 import java.util.Map; 30  31 /** 32  * Base class for all network requests. 33  * 34  * @param 
      
        The type of parsed response this request expects. 35  */ 36 public abstract class Request
       
         implements Comparable
        
         
          > { 37  38     /** 39      * Default encoding for POST or PUT parameters. See {@link #getParamsEncoding()}. 40      */ 41     private static final String DEFAULT_PARAMS_ENCODING = "UTF-8"; 42  43     /** 44      * Supported request methods. 45      */ 46     public interface Method { 47         int DEPRECATED_GET_OR_POST = -1; 48         int GET = 0; 49         int POST = 1; 50         int PUT = 2; 51         int DELETE = 3; 52         int HEAD = 4; 53         int OPTIONS = 5; 54         int TRACE = 6; 55         int PATCH = 7; 56     } 57  58     /** An event log tracing the lifetime of this request; for debugging. */ 59     private final MarkerLog mEventLog = MarkerLog.ENABLED ? new MarkerLog() : null; 60  61     /** 62      * Request method of this request.  Currently supports GET, POST, PUT, DELETE, HEAD, OPTIONS, 63      * TRACE, and PATCH. 64      */ 65     private final int mMethod; 66  67     /** URL of this request. */ 68     private final String mUrl; 69  70     /** The redirect url to use for 3xx http responses */ 71     private String mRedirectUrl; 72  73     /** The unique identifier of the request */ 74     private String mIdentifier; 75  76     /** Default tag for {@link TrafficStats}. */ 77     private final int mDefaultTrafficStatsTag; 78  79     /** Listener interface for errors. */ 80     private Response.ErrorListener mErrorListener; 81  82     /** Sequence number of this request, used to enforce FIFO ordering. */ 83     private Integer mSequence; 84  85     /** The request queue this request is associated with. */ 86     private RequestQueue mRequestQueue; 87  88     /** Whether or not responses to this request should be cached. */ 89     private boolean mShouldCache = true; 90  91     /** Whether or not this request has been canceled. */ 92     private boolean mCanceled = false; 93  94     /** Whether or not a response has been delivered for this request yet. */ 95     private boolean mResponseDelivered = false; 96  97     /** The retry policy for this request. */ 98     private RetryPolicy mRetryPolicy; 99 100     /**101      * When a request can be retrieved from cache but must be refreshed from102      * the network, the cache entry will be stored here so that in the event of103      * a "Not Modified" response, we can be sure it hasn't been evicted from cache.104      */105     private Cache.Entry mCacheEntry = null;106 107     /** An opaque token tagging this request; used for bulk cancellation. */108     private Object mTag;109 110     /**111      * Creates a new request with the given URL and error listener.  Note that112      * the normal response listener is not provided here as delivery of responses113      * is provided by subclasses, who have a better idea of how to deliver an114      * already-parsed response.115      *116      * @deprecated Use {@link #Request(int, String, com.android.volley.Response.ErrorListener)}.117      */118     @Deprecated119     public Request(String url, Response.ErrorListener listener) {120         this(Method.DEPRECATED_GET_OR_POST, url, listener);121     }122 123     /**124      * Creates a new request with the given method (one of the values from {@link Method}),125      * URL, and error listener.  Note that the normal response listener is not provided here as126      * delivery of responses is provided by subclasses, who have a better idea of how to deliver127      * an already-parsed response.128      */129     public Request(int method, String url, Response.ErrorListener listener) {130         mMethod = method;131         mUrl = url;132         mIdentifier = createIdentifier(method, url);133         mErrorListener = listener;134         setRetryPolicy(new DefaultRetryPolicy());135 136         mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);137     }138 139     /**140      * Return the method for this request.  Can be one of the values in {@link Method}.141      */142     public int getMethod() {143         return mMethod;144     }145 146     /**147      * Set a tag on this request. Can be used to cancel all requests with this148      * tag by {@link RequestQueue#cancelAll(Object)}.149      *150      * @return This Request object to allow for chaining.151      */152     public Request
           setTag(Object tag) {153         mTag = tag;154         return this;155     }156 157     /**158      * Returns this request's tag.159      * @see Request#setTag(Object)160      */161     public Object getTag() {162         return mTag;163     }164 165     /**166      * @return this request's {@link com.android.volley.Response.ErrorListener}.167      */168     public Response.ErrorListener getErrorListener() {169         return mErrorListener;170     }171 172     /**173      * @return A tag for use with {@link TrafficStats#setThreadStatsTag(int)}174      */175     public int getTrafficStatsTag() {176         return mDefaultTrafficStatsTag;177     }178 179     /**180      * @return The hashcode of the URL's host component, or 0 if there is none.181      */182     private static int findDefaultTrafficStatsTag(String url) {183         if (!TextUtils.isEmpty(url)) {184             Uri uri = Uri.parse(url);185             if (uri != null) {186                 String host = uri.getHost();187                 if (host != null) {188                     return host.hashCode();189                 }190             }191         }192         return 0;193     }194 195     /**196      * Sets the retry policy for this request.197      *198      * @return This Request object to allow for chaining.199      */200     public Request
           setRetryPolicy(RetryPolicy retryPolicy) {201         mRetryPolicy = retryPolicy;202         return this;203     }204 205     /**206      * Adds an event to this request's event log; for debugging.207      */208     public void addMarker(String tag) {209         if (MarkerLog.ENABLED) {210             mEventLog.add(tag, Thread.currentThread().getId());211         }212     }213 214     /**215      * Notifies the request queue that this request has finished (successfully or with error).216      *217      * 
          
Also dumps all events from this request's event log; for debugging.
218      */219     void finish(final String tag) {220         if (mRequestQueue != null) {221             mRequestQueue.finish(this);222             onFinish();223         }224         if (MarkerLog.ENABLED) {225             final long threadId = Thread.currentThread().getId();226             if (Looper.myLooper() != Looper.getMainLooper()) {227                 // If we finish marking off of the main thread, we need to228                 // actually do it on the main thread to ensure correct ordering.229                 Handler mainThread = new Handler(Looper.getMainLooper());230                 mainThread.post(new Runnable() {231                     @Override232                     public void run() {233                         mEventLog.add(tag, threadId);234                         mEventLog.finish(this.toString());235                     }236                 });237                 return;238             }239 240             mEventLog.add(tag, threadId);241             mEventLog.finish(this.toString());242         }243     }244 245     /**246      * clear listeners when finished247      */248     protected void onFinish() {249         mErrorListener = null;250     }251 252     /**253      * Associates this request with the given queue. The request queue will be notified when this254      * request has finished.255      *256      * @return This Request object to allow for chaining.257      */258     public Request
           setRequestQueue(RequestQueue requestQueue) {259         mRequestQueue = requestQueue;260         return this;261     }262 263     /**264      * Sets the sequence number of this request.  Used by {@link RequestQueue}.265      *266      * @return This Request object to allow for chaining.267      */268     public final Request
           setSequence(int sequence) {269         mSequence = sequence;270         return this;271     }272 273     /**274      * Returns the sequence number of this request.275      */276     public final int getSequence() {277         if (mSequence == null) {278             throw new IllegalStateException("getSequence called before setSequence");279         }280         return mSequence;281     }282 283     /**284      * Returns the URL of this request.285      */286     public String getUrl() {287         return (mRedirectUrl != null) ? mRedirectUrl : mUrl;288     }289 290     /**291      * Returns the URL of the request before any redirects have occurred.292      */293     public String getOriginUrl() {294         return mUrl;295     }296 297     /**298      * Returns the identifier of the request.299      */300     public String getIdentifier() {301         return mIdentifier;302     }303 304     /**305      * Sets the redirect url to handle 3xx http responses.306      */307     public void setRedirectUrl(String redirectUrl) {308         mRedirectUrl = redirectUrl;309     }310 311     /**312      * Returns the cache key for this request.  By default, this is the URL.313      */314     public String getCacheKey() {315         return mMethod + ":" + mUrl;316     }317 318     /**319      * Annotates this request with an entry retrieved for it from cache.320      * Used for cache coherency support.321      *322      * @return This Request object to allow for chaining.323      */324     public Request
           setCacheEntry(Cache.Entry entry) {325         mCacheEntry = entry;326         return this;327     }328 329     /**330      * Returns the annotated cache entry, or null if there isn't one.331      */332     public Cache.Entry getCacheEntry() {333         return mCacheEntry;334     }335 336     /**337      * Mark this request as canceled.  No callback will be delivered.338      */339     public void cancel() {340         mCanceled = true;341     }342 343     /**344      * Returns true if this request has been canceled.345      */346     public boolean isCanceled() {347         return mCanceled;348     }349 350     /**351      * Returns a list of extra HTTP headers to go along with this request. Can352      * throw {@link AuthFailureError} as authentication may be required to353      * provide these values.354      * @throws AuthFailureError In the event of auth failure355      */356     public Map
          
            getHeaders() throws AuthFailureError {357         return Collections.emptyMap();358     }359 360     /**361      * Returns a Map of POST parameters to be used for this request, or null if362      * a simple GET should be used.  Can throw {@link AuthFailureError} as363      * authentication may be required to provide these values.364      *365      * 
           
Note that only one of getPostParams() and getPostBody() can return a non-null366 * value.
367      * @throws AuthFailureError In the event of auth failure368      *369      * @deprecated Use {@link #getParams()} instead.370      */371     @Deprecated372     protected Map
           
             getPostParams() throws AuthFailureError {373 return getParams();374 }375 376 /**377 * Returns which encoding should be used when converting POST parameters returned by378 * {@link #getPostParams()} into a raw POST body.379 *380 * 
            
This controls both encodings:381 * 
            
             382 * 
             
The string encoding used when converting parameter names and values into bytes prior383 * to URL encoding them.
384 * 
             
The string encoding used when converting the URL encoded parameters into a raw385 * byte array.
386 * 
            
387 *388 * @deprecated Use {@link #getParamsEncoding()} instead.389 */390 @Deprecated391 protected String getPostParamsEncoding() {392 return getParamsEncoding();393 }394 395 /**396 * @deprecated Use {@link #getBodyContentType()} instead.397 */398 @Deprecated399 public String getPostBodyContentType() {400 return getBodyContentType();401 }402 403 /**404 * Returns the raw POST body to be sent.405 *406 * @throws AuthFailureError In the event of auth failure407 *408 * @deprecated Use {@link #getBody()} instead.409 */410 @Deprecated411 public byte[] getPostBody() throws AuthFailureError {412 // Note: For compatibility with legacy clients of volley, this implementation must remain413 // here instead of simply calling the getBody() function because this function must414 // call getPostParams() and getPostParamsEncoding() since legacy clients would have415 // overridden these two member functions for POST requests.416 Map
            
              postParams = getPostParams();417 if (postParams != null && postParams.size() > 0) {418 return encodeParameters(postParams, getPostParamsEncoding());419 }420 return null;421 }422 423 /**424 * Returns a Map of parameters to be used for a POST or PUT request. Can throw425 * {@link AuthFailureError} as authentication may be required to provide these values.426 *427 * 
             
Note that you can directly override {@link #getBody()} for custom data.
428 *429 * @throws AuthFailureError in the event of auth failure430 */431 protected Map
             
               getParams() throws AuthFailureError {432 return null;433 }434 435 /**436 * Returns which encoding should be used when converting POST or PUT parameters returned by437 * {@link #getParams()} into a raw POST or PUT body.438 *439 * 
              
This controls both encodings:440 * 
              
               441 * 
               
The string encoding used when converting parameter names and values into bytes prior442 * to URL encoding them.
443 * 
               
The string encoding used when converting the URL encoded parameters into a raw444 * byte array.
445 * 
              
446 */447 protected String getParamsEncoding() {448 return DEFAULT_PARAMS_ENCODING;449 }450 451 /**452 * Returns the content type of the POST or PUT body.453 */454 public String getBodyContentType() {455 return "application/x-www-form-urlencoded; charset=" + getParamsEncoding();456 }457 458 /**459 * Returns the raw POST or PUT body to be sent.460 *461 * 
              
By default, the body consists of the request parameters in462 * application/x-www-form-urlencoded format. When overriding this method, consider overriding463 * {@link #getBodyContentType()} as well to match the new body format.464 *465 * @throws AuthFailureError in the event of auth failure466 */467 public byte[] getBody() throws AuthFailureError {468 Map
               
                 params = getParams();469 if (params != null && params.size() > 0) {470 return encodeParameters(params, getParamsEncoding());471 }472 return null;473 }474 475 /**476 * Converts 
                params into an application/x-www-form-urlencoded encoded string.477 */478 private byte[] encodeParameters(Map
                
                  params, String paramsEncoding) {479 StringBuilder encodedParams = new StringBuilder();480 try {481 for (Map.Entry
                 
                   entry : params.entrySet()) {482 encodedParams.append(URLEncoder.encode(entry.getKey(), paramsEncoding));483 encodedParams.append('=');484 encodedParams.append(URLEncoder.encode(entry.getValue(), paramsEncoding));485 encodedParams.append('&');486 }487 return encodedParams.toString().getBytes(paramsEncoding);488 } catch (UnsupportedEncodingException uee) {489 throw new RuntimeException("Encoding not supported: " + paramsEncoding, uee);490 }491 }492 493 /**494 * Set whether or not responses to this request should be cached.495 *496 * @return This Request object to allow for chaining.497 */498 public final Request
                   setShouldCache(boolean shouldCache) {499 mShouldCache = shouldCache;500 return this;501 }502 503 /**504 * Returns true if responses to this request should be cached.505 */506 public final boolean shouldCache() {507 return mShouldCache;508 }509 510 /**511 * Priority values. Requests will be processed from higher priorities to512 * lower priorities, in FIFO order.513 */514 public enum Priority {515 LOW,516 NORMAL,517 HIGH,518 IMMEDIATE519 }520 521 /**522 * Returns the {@link Priority} of this request; {@link Priority#NORMAL} by default.523 */524 public Priority getPriority() {525 return Priority.NORMAL;526 }527 528 /**529 * Returns the socket timeout in milliseconds per retry attempt. (This value can be changed530 * per retry attempt if a backoff is specified via backoffTimeout()). If there are no retry531 * attempts remaining, this will cause delivery of a {@link TimeoutError} error.532 */533 public final int getTimeoutMs() {534 return mRetryPolicy.getCurrentTimeout();535 }536 537 /**538 * Returns the retry policy that should be used for this request.539 */540 public RetryPolicy getRetryPolicy() {541 return mRetryPolicy;542 }543 544 /**545 * Mark this request as having a response delivered on it. This can be used546 * later in the request's lifetime for suppressing identical responses.547 */548 public void markDelivered() {549 mResponseDelivered = true;550 }551 552 /**553 * Returns true if this request has had a response delivered for it.554 */555 public boolean hasHadResponseDelivered() {556 return mResponseDelivered;557 }558 559 /**560 * Subclasses must implement this to parse the raw network response561 * and return an appropriate response type. This method will be562 * called from a worker thread. The response will not be delivered563 * if you return null.564 * @param response Response from the network565 * @return The parsed response, or null in the case of an error566 */567 abstract protected Response
                  
                    parseNetworkResponse(NetworkResponse response);568 569 /**570 * Subclasses can override this method to parse 'networkError' and return a more specific error.571 *572 * 
                  
                 
                
               
              
The default implementation just returns the passed 'networkError'.
573 *574 * @param volleyError the error retrieved from the network575 * @return an NetworkError augmented with additional information576 */577 protected VolleyError parseNetworkError(VolleyError volleyError) {578 return volleyError;579 }580 581 /**582 * Subclasses must implement this to perform delivery of the parsed583 * response to their listeners. The given response is guaranteed to584 * be non-null; responses that fail to parse are not delivered.585 * @param response The parsed response returned by586 * {@link #parseNetworkResponse(NetworkResponse)}587 */588 abstract protected void deliverResponse(T response);589 590 /**591 * Delivers error message to the ErrorListener that the Request was592 * initialized with.593 *594 * @param error Error details595 */596 public void deliverError(VolleyError error) {597 if (mErrorListener != null) {598 mErrorListener.onErrorResponse(error);599 }600 }601 602 /**603 * Our comparator sorts from high to low priority, and secondarily by604 * sequence number to provide FIFO ordering.605 */606 @Override607 public int compareTo(Request
              
                other) {608 Priority left = this.getPriority();609 Priority right = other.getPriority();610 611 // High-priority requests are "lesser" so they are sorted to the front.612 // Equal priorities are sorted by sequence number to provide FIFO ordering.613 return left == right ?614 this.mSequence - other.mSequence :615 right.ordinal() - left.ordinal();616 }617 618 @Override619 public String toString() {620 String trafficStatsTag = "0x" + Integer.toHexString(getTrafficStatsTag());621 return (mCanceled ? "[X] " : "[ ] ") + getUrl() + " " + trafficStatsTag + " "622 + getPriority() + " " + mSequence;623 }624 625 private static long sCounter;626 /**627 * sha1(Request:method:url:timestamp:counter)628 * @param method http method629 * @param url http request url630 * @return sha1 hash string631 */632 private static String createIdentifier(final int method, final String url) {633 return InternalUtils.sha1Hash("Request:" + method + ":" + url +634 ":" + System.currentTimeMillis() + ":" + (sCounter++));635 }636 }
              
             
            
           
          
         
        
       
      

 Request<T>中的泛型T，是指解析response以后的结果。在上一篇文章中我们知道，ResponseDelivery会把response分派给对应的request(中文翻译就是，把响应分派给对应的请求)。在我们定义的请求中，需要重写parseNetworkResponse(NetworkResponse response)这个方法，解析请求，解析出来的结果，就是T类型的。

首先是一些属性

1 /**   2  * Base class for all network requests.   3  * 请求基类   4  * @param 
     
       The type of parsed response this request expects.   5  * T为响应类型   6  */    7 public abstract class Request
      
        implements Comparable
       
        
         > {    8     9     /**  10      * Default encoding for POST or PUT parameters. See {@link #getParamsEncoding()}.  11      * 默认编码  12      */   13     private static final String DEFAULT_PARAMS_ENCODING = "UTF-8";   14    15     /**  16      * Supported request methods.  17      * 支持的请求方式  18      */   19     public interface Method {   20         int DEPRECATED_GET_OR_POST = -1;   21         int GET = 0;   22         int POST = 1;   23         int PUT = 2;   24         int DELETE = 3;   25         int HEAD = 4;   26         int OPTIONS = 5;   27         int TRACE = 6;   28         int PATCH = 7;   29     }   30    31     /**   32      * An event log tracing the lifetime of this request; for debugging.  33      * 用于跟踪请求的生存时间，用于调试   34      * */   35     private final MarkerLog mEventLog = MarkerLog.ENABLED ? new MarkerLog() : null;   36    37     /**  38      * Request method of this request.  Currently supports GET, POST, PUT, DELETE, HEAD, OPTIONS,  39      * TRACE, and PATCH.  40      * 当前请求方式  41      */   42     private final int mMethod;   43    44     /**   45      * URL of this request.   46      * 请求地址   47      */   48     private final String mUrl;   49        50     /**   51      * The redirect url to use for 3xx http responses   52      * 重定向地址   53      */   54     private String mRedirectUrl;   55    56     /**   57      * The unique identifier of the request  58      * 该请求的唯一凭证   59      */   60     private String mIdentifier;   61    62     /**   63      * Default tag for {@link TrafficStats}.  64      * 流量统计标签   65      */   66     private final int mDefaultTrafficStatsTag;   67    68     /**   69      * Listener interface for errors.  70      * 错误监听器   71      */   72     private final Response.ErrorListener mErrorListener;   73    74     /**   75      * Sequence number of this request, used to enforce FIFO ordering.  76      * 请求序号，用于fifo算法   77      */   78     private Integer mSequence;   79    80     /**   81      * The request queue this request is associated with.  82      * 请求所在的请求队列   83      */   84     private RequestQueue mRequestQueue;   85    86     /**   87      * Whether or not responses to this request should be cached.  88      * 是否使用缓存响应请求   89      */   90     private boolean mShouldCache = true;   91    92     /**   93      * Whether or not this request has been canceled.  94      * 该请求是否被取消   95      */   96     private boolean mCanceled = false;   97    98     /**   99      * Whether or not a response has been delivered for this request yet. 100      * 该请求是否已经被响应  101      */  102     private boolean mResponseDelivered = false;  103       104     /** 105      * A cheap variant of request tracing used to dump slow requests. 106      * 一个简单的变量，跟踪请求，用来抛弃过慢的请求 107      * 请求产生时间  108      */  109     private long mRequestBirthTime = 0;  110   111     /** Threshold at which we should log the request (even when debug logging is not enabled). */  112     private static final long SLOW_REQUEST_THRESHOLD_MS = 3000;  113   114     /**  115      * The retry policy for this request. 116      * 请求重试策略  117      */  118     private RetryPolicy mRetryPolicy;  119   120     /** 121      * When a request can be retrieved from cache but must be refreshed from 122      * the network, the cache entry will be stored here so that in the event of 123      * a "Not Modified" response, we can be sure it hasn't been evicted from cache. 124      * 缓存记录。当请求可以从缓存中获得响应，但必须从网络上更新时。我们保留这个缓存记录，所以一旦从网络上获得的响应带有Not Modified 125      * (没有更新)时，来保证这个缓存没有被回收. 126      */  127     private Cache.Entry mCacheEntry = null;  128   129     /** 130      *  An opaque token tagging this request; used for bulk cancellation. 131      *  用于自定义标记，可以理解为用于请求的分类  132      */  133     private Object mTag;
        
       
      
     

接下来看构造方法

/**      * 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;          mIdentifier = createIdentifier(method, url);//为请求创建唯一凭证          mErrorListener = listener;//设定监听器          setRetryPolicy(new DefaultRetryPolicy());//设置默认重试策略            mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);//设置流量标志      }

首先是请求方式，请求地址的设定，这是作为一个请求必须有的。然后是监听器的设定，注意这里只是这是了ErrorListner，说明errorListener是必须的，但是正确响应，我们有可能不处理。这样设定是合理的，因为出错了，我们必须处理，至于请求成功，我们可以不处理。那么我们想处理成功的请求怎么办呢，这需要在子类中重写构造方法(例如StringRequest)。

 

然后是创建了一个唯一凭证

/**      *  sha1(Request:method:url:timestamp:counter)      * @param method http method      * @param url               http request url      * @return sha1 hash string      * 利用请求方式和地址，进行sha1加密，创建该请求的唯一凭证      */      private static String createIdentifier(final int method, final String url) {          return InternalUtils.sha1Hash("Request:" + method + ":" + url +                  ":" + System.currentTimeMillis() + ":" + (sCounter++));      }

由上面的方法可以看出，这个凭证和当前时间有关，因此是独一无二的

 

接着是设置重试策略，这个类等下再介绍，接下来是流量标志的设置，所谓流量标志，是用于调试日志记录的，不是重点

/**      * @return The hashcode of the URL's host component, or 0 if there is none.      * 返回url的host(主机地址)部分的hashcode，如果host不存在，返回0      */      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;      }

我们再回过头来看这个重试策略。

 

volley为重试策略专门定义了一个类，这样我们就可以根据需要实现自己的重试策略了，至于源码内部，为我们提供了一个默认的重试策略DefaultRetryPolicy()

要介绍重试策略，我们先看重试策略的基类RetryPolicy

/**  * Retry policy for a request.  * 请求重试策略类  */  public interface RetryPolicy {        /**      * Returns the current timeout (used for logging).      * 获得当前时间，用于日志      */      public int getCurrentTimeout();        /**      * Returns the current retry count (used for logging).      * 返回当前重试次数，用于日志      */      public int getCurrentRetryCount();        /**      * Prepares for the next retry by applying a backoff to the timeout.      * @param error The error code of the last attempt.      * @throws VolleyError In the event that the retry could not be performed (for example if we      * ran out of attempts), the passed in error is thrown.      * 重试实现      */      public void retry(VolleyError error) throws VolleyError;  }

重要的是retry()这个方法，我们来看DefaultRetryPolicy里面这个方法的具体实现

/**      * Prepares for the next retry by applying a backoff to the timeout.      * @param error The error code of the last attempt.      */      @Override      public void retry(VolleyError error) throws VolleyError {          mCurrentRetryCount++;//当前重试次数          mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);//当前超出时间          if (!hasAttemptRemaining()) {
   //是否已经到达最大重试次数              throw error;          }      }        /**      * Returns true if this policy has attempts remaining, false otherwise.      * 是否还重试      */      protected boolean hasAttemptRemaining() {          return mCurrentRetryCount <= mMaxNumRetries;//最大重试次数      }

可以看到，在默认的重试策略中，只是简单地统计了重试的次数，然后，在超出最大次数以后，抛出异常。

 

就这么简单，那么究竟volley是怎么实现重试的呢？

实际上，当从队列中取出一个request去进行网络请求的时候，我们是写在一个死循环里面的(在以后的代码可以看到，这样不贴出来以免类过多造成困扰)。

一旦请求失败，就会调用上面的retry()方法，但是没有跳出循环。直到请求成功获得response，才return。如果一直请求失败，根据上面的重试策略，最后会抛出VolleyError异常,这个异常不处理，而是通过throws向外抛，从而结束死循环。

从程序设计的角度来说，通过抛出异常结束死循环，显得不是那么的优雅(通常我们用设置标记的方法结束循环)，但是在volley中使用了这个方式，原因是对于这个异常，要交给程序员自己处理，虽然这样使异常传递的过程变得复杂，但是增加了程序的灵活性。

最终的异常，我们会在Request<T>的parseNetworkError()和deliverError()方法里面处理，parseNetworkError()用于解析Volleyerror，deliverError()方法回调了上面一开始就提到的ErrorListener

/**      * 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      * 解析网络错误      */      public VolleyError parseNetworkError(VolleyError volleyError) {          return volleyError;      }        /**      * 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);          }      }

其实除了上面两个处理错误的方法，还有两个方法用于处理成功响应,是必须要继承的

/**      * 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      * 解析响应      */      public abstract Response
     
       parseNetworkResponse(NetworkResponse response);  
      
/**      * 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)}      * 分发响应      */      public abstract void deliverResponse(T response);
     

parseNetworkResponse(NetworkResponse response)用于将网络response解析为本地response，解析出来的response,会交给deliverResponse(T response)方法。

 

为什么要解析，其实上面已经说过，要将结果解析为T类型。至于这两个方法，其实是在ResponseDelivery响应分发器里面调用的。

看完初始化方法，我们来看结束请求的方法finish()，有时候我们想要主动终止请求，例如停止下载文件，又或者请求已经成功了，我们从队列中去除这个请求

1 /**  2      * Notifies the request queue that this request has finished (successfully or with error).  3      * 提醒请求队列，当前请求已经完成(失败或成功)  4      * 
Also dumps all events from this request's event log; for debugging.
  5      *   6      */   7     public void finish(final String tag) {   8         if (mRequestQueue != null) {   9             mRequestQueue.finish(this);//该请求完成  10         }  11         if (MarkerLog.ENABLED) {
   //如果开启调试  12             final long threadId = Thread.currentThread().getId();//线程id  13             if (Looper.myLooper() != Looper.getMainLooper()) {
   //请求不是在主线程  14                 // If we finish marking off of the main thread, we need to  15                 // actually do it on the main thread to ensure correct ordering.  16                 //如果我们不是在主线程记录log，我们需要在主线程做这项工作来保证正确的顺序  17                 Handler mainThread = new Handler(Looper.getMainLooper());  18                 mainThread.post(new Runnable() {  19                     @Override  20                     public void run() {  21                         mEventLog.add(tag, threadId);  22                         mEventLog.finish(this.toString());  23                     }  24                 });  25                 return;  26             }  27             //如果在主线程，直接记录  28             mEventLog.add(tag, threadId);  29             mEventLog.finish(this.toString());  30         } else {
   //不开启调试  31             long requestTime = SystemClock.elapsedRealtime() - mRequestBirthTime;  32             if (requestTime >= SLOW_REQUEST_THRESHOLD_MS) {  33                 VolleyLog.d("%d ms: %s", requestTime, this.toString());  34             }  35         }  36     }

上面主要是做了一些日志记录的工作，最重要的是调用了mRequestQueue的finish()方法，来从队列中去除这个请求。

 

看完上面的介绍以后，大家是否注意到，Request<T>继承了Comparable<Request<T>>接口，为什么要继承这个接口了，我们当然要来看compareTo()方法了

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

这个方法比较了两个请求的优先级，如果优先级相等，就按照顺序

 

实现这个接口的目的，正如上一篇文章提到的，有的请求比较重要，希望早点执行，也就是说让它排在请求队列的前头

通过比较方法，我们就可以设定请求在请求队列中排队顺序的根据，从而让优先级高的排在前面。

 

OK，Request<T>就基本介绍完了，当然有些属性，例如缓存mCacheEntry，mRedirectUrl重定向地址等我们还没有用到，我们先记住它们，在以后会使用到的。

其实Request<T>类并不复杂，主要就是一些属性的设置，这些属性有的比较难考虑到，例如优先级，重定向地址，自定义标记，重试策略等。

 

最后，我们通过StringRequest来看一下Request<T>类的具体实现

/**  * A canned request for retrieving the response body at a given URL as a String.  */  public class StringRequest extends Request
     
       {      private final Listener
      
        mListener;        /**      * Creates a new request with the given method.      *      * @param method the request {@link Method} to use      * @param url URL to fetch the string at      * @param listener Listener to receive the String response      * @param errorListener Error listener, or null to ignore errors      */      public StringRequest(int method, String url, Listener
       
         listener,              ErrorListener errorListener) {          super(method, url, errorListener);          mListener = listener;      }
       
      
     

上面的构造方法中，添加了一个新的接口Listener<String> listener,用于监听成功的response

 

然后是parseNetworkResponse(NetworkResponse response)，这个方法

@Override      public Response
     
       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));      }
     

可以看到，将NetworkResponse解析为String类型的了，然后再构造成对应的本地response

@Override      public void deliverResponse(String response) {          mListener.onResponse(response);      }

至于deliverResponse(String response)，则调用了构造方法里面要求的，新的监听器。

 

到此为止，对于Request<T>的介绍就结束了，由于Request<T>和其他类的耦合并不是特别重，相信是比较容易理解。

在下一篇文章中，我们会来看RequestQueue队列，看看这个队列的作用到底是什么，我们为什么要创建一个队列来保存request而不是直接每个request开启一个线程去加载网络数据。